1 J7 @2 `; Z! ^( `【注意】在使用之前，必须先导入math模块，以开方函数 sqrt 为例，介绍2种引入方式及各自使用方法。

方法1：

1. >>> import math
   
2. >>> math.sqrt(9)
   0 V4 @# [. b9 M9 T7 X
3. 3.0

复制代码

方法2：
6 M. }+ ]8 E% A

1. >>> from math import sqrt
   $ y( }+ `3 ~/ }
2. >>> sqrt(9)
   - v5 Z) T, Y+ H, B7 }4 }
3. 3.0

复制代码

7 I0 e6 H5 Z% u$ ]$ Q( q

---

math.e  表示一个常量
/ d' n# x! \/ \1 W( j1 N8 }4 ~/ ~

1. #表示一个常量
   
2. >>> math.e
   
3. 2.718281828459045

复制代码

' _* Y3 X( F8 R% f7 ]math.pi  数字常量，圆周率
( T# C8 J6 E, \' g9 g, l2 I

1. #数字常量，圆周率
   
2. >>> print(math.pi)
   
3. 3.141592653589793

复制代码

math.ceil(x)  取大于等于x的最小的整数值，如果x是一个整数，则返回x
$ c' x- `" |0 L) H7 M1 o) e. F

1. #取大于等于x的最小的整数值，如果x是一个整数，则返回x
   
2. ceil(x)
   
3. Return the ceiling of x as an int.
   
4. This is the smallest integral value >= x.
   $ v$ E" o: h: I) D9 D
5. 
   
6. >>> math.ceil(4.01)
   / c  G7 M: V: U, a3 @7 r
7. 5
   ) u; n  a) _9 J, |6 r
8. >>> math.ceil(4.99)
   
9. 5
   : x) F5 p- {) \+ u1 p; G
10. >>> math.ceil(-3.99)
    
11. -3
    ( s* c  A' ?0 y! J, q. Y
12. >>> math.ceil(-3.01)
    ( a6 {! [# v! t1 ~; t! z+ V; N2 v
13. -3

复制代码

) U  T) x0 L3 U" z2 G1 gmath.floor(x)  取小于等于x的最大的整数值，如果x是一个整数，则返回自身
% i& u9 {5 M1 o' }1 j$ f, U

1. #取小于等于x的最大的整数值，如果x是一个整数，则返回自身
   9 P* q4 O. b0 C; [! l+ ?
2. floor(x)
   ) f1 M; L: Z; B) g
3. Return the floor of x as an int.
   0 D; X: X1 L- K5 E
4. This is the largest integral value <= x.
   . i. |# o' ?' }0 M9 }& L) {; b3 K1 ^
5. >>> math.floor(4.1)
   , z4 A& n, S& s- W9 O( i/ g
6. 4
   % j# T+ W2 p' p! T/ {6 W$ |
7. >>> math.floor(4.999)
   
8. 4
   + d  N7 f/ x+ X
9. >>> math.floor(-4.999)
   ) j8 G0 [1 R7 ^, _! Y
10. -5
    ' v" i* J' P( F) o4 e6 S
11. >>> math.floor(-4.01)
    ! g% K) X: E4 Y( w+ Y6 [
12. -5

复制代码

math.pow(x,y)  返回x的y次方，即x**y

1. #返回x的y次方，即x**y
   3 p1 o+ J  c2 E: ?! G% S. x
2. pow(x, y)
   9 y. b% r2 j6 t* S3 H! G, G# `6 D4 B" e& ^
3. Return x**y (x to the power of y).
   
4. >>> math.pow(3,4)
   
5. 81.0
   . D7 t/ z( C% \
6. >>>
   
7. >>> math.pow(2,7)
   ' n1 R# V, [6 ?; _
8. 128.0

复制代码

; U$ i3 ]3 ^% {+ j7 {! {$ |math.log(x)  返回x的自然对数，默认以e为基数，base参数给定时，将x的对数返回给定的base，计算式为：log(x)/log(base)
( }( Q6 l# P+ K/ Y% E

1. #返回x的自然对数，默认以e为基数，base参数给定时，将x的对数返回给定的base,计算式为：log(x)/log(base)
   3 f  m" o4 O, V! |% M: u; V
2. log(x[, base])
   
3. Return the logarithm of x to the given base.
   & c7 c! B$ N$ D
4. If the base not specified, returns the natural logarithm (base e) of x.
   3 e& m0 D( h+ m% |! V# w" Q
5. >>> math.log(10)
   
6. 2.302585092994046
   / _1 l6 x+ V& m+ W( X" g
7. >>> math.log(11)
   ; N. F# V" x. g& @' N& k4 x% u
8. 2.3978952727983707
   
9. >>> math.log(20)
   2 Y1 Y# o+ ~3 j% _+ v3 ?
10. 2.995732273553991

复制代码

math.sin(x)  求x(x为弧度)的正弦值
8 {" s) e  q$ `% Y2 J9 X

1. #求x(x为弧度)的正弦值
   
2. sin(x)
   5 H7 x4 r& H7 ~5 Z
3. Return the sine of x (measured in radians).
   ) s% U# ~% M- w( {3 _
4. >>> math.sin(math.pi/4)
   5 j) _' E, y, M- G9 T2 e7 a: d+ w
5. 0.7071067811865475
   
6. >>> math.sin(math.pi/2)
   4 K. l4 t4 {4 P: d) ?/ n3 T
7. 1.0
   
8. >>> math.sin(math.pi/3)
   2 t. }: F8 R: L5 g0 n# `. x
9. 0.8660254037844386

复制代码

math.cos(x)  求x的余弦，x必须是弧度

1. #求x的余弦，x必须是弧度
   
2. cos(x)
   
3. Return the cosine of x (measured in radians).
   
4. #math.pi/4表示弧度，转换成角度为45度
   
5. >>> math.cos(math.pi/4)
   
6. 0.7071067811865476
   , R3 r8 M& i$ g; |- D  t
7. math.pi/3表示弧度，转换成角度为60度
   , j) x! |: J% d# z3 g; F
8. >>> math.cos(math.pi/3)
   
9. 0.5000000000000001
   : h7 d$ t+ S) a& J! ]& ]( p# _1 I
10. math.pi/6表示弧度，转换成角度为30度
    + |$ m- ~1 u/ v* z3 N0 d. u7 _2 ]
11. >>> math.cos(math.pi/6)
    
12. 0.8660254037844387

复制代码

2 {" B, Y/ M4 i& W$ e) Tmath.tan(x)  返回x(x为弧度)的正切值
. F/ O; _9 {  V% l$ E3 }

1. #返回x(x为弧度)的正切值
   
2. tan(x)
   
3. Return the tangent of x (measured in radians).
   
4. >>> math.tan(math.pi/4)
   
5. 0.9999999999999999
     v9 c) H; n* v& C) A
6. >>> math.tan(math.pi/6)
   & h3 b1 K+ z2 c
7. 0.5773502691896257
   
8. >>> math.tan(math.pi/3)
   3 _# v2 I& S' l7 E9 `3 n9 @0 A
9. 1.7320508075688767

复制代码

* }( D+ C( p7 f0 U' Jmath.degrees(x)  把x从弧度转换成角度
1 ?3 I- p) y0 \  J  w

1. #把x从弧度转换成角度
   2 ]2 J9 z9 P; U% z' t( L- u
2. degrees(x)
   7 C5 ]# s4 i1 w5 Y- z
3. Convert angle x from radians to degrees.
   
4. 
   
5. >>> math.degrees(math.pi/4)
   9 E* I% t$ L4 O' a
6. 45.0
   7 {0 M- g% X4 L7 |% i
7. >>> math.degrees(math.pi)
   1 }8 p& n( [2 o
8. 180.0
   * D4 N" F9 o5 k  s
9. >>> math.degrees(math.pi/6)
   6 q% @( D2 C* z7 i5 X
10. 29.999999999999996
    - |% n$ D. ~; e* |! l8 w7 `& F$ W
11. >>> math.degrees(math.pi/3)
    
12. 59.99999999999999

复制代码

math.radians(x)  把角度x转换成弧度
& l+ @% V4 \6 w( Q

1. #把角度x转换成弧度
   
2. radians(x)
   " W( D- G/ @  q' I  u" t
3. Convert angle x from degrees to radians.
   
4. >>> math.radians(45)
   
5. 0.7853981633974483
   
6. >>> math.radians(60)
   9 T+ N$ V  u# i5 K" F; U/ F
7. 1.0471975511965976

复制代码

3 A# E  R$ b, N( z$ Mmath.copysign(x,y)  把y的正负号加到x前面，可以使用0
1 P) S( r. K, ^8 |5 x; S

1. #把y的正负号加到x前面，可以使用0
   ) O+ q. \( [; v
2. copysign(x, y)
   
3. Return a float with the magnitude (absolute value) of x but the sign
   $ F8 e2 `6 ~: V/ {4 }; H9 X: x5 n
4. of y. On platforms that support signed zeros, copysign(1.0, -0.0)
   , U: b  o8 {3 E( q# ^9 G
5. returns -1.0.
   
6. 
   
7. >>> math.copysign(2,3)
   
8. 2.0
   
9. >>> math.copysign(2,-3)
   
10. -2.0
    
11. >>> math.copysign(3,8)
    ( k  X& ]0 C% r. y
12. 3.0
    ( Y7 b* M  k9 b
13. >>> math.copysign(3,-8)
    
14. -3.0

复制代码

math.exp(x)  返回math.e,也就是2.71828的x次方

1. #返回math.e,也就是2.71828的x次方
   / O* o# a; z' Y) T. S
2. exp(x)
   $ u0 R. w1 B* ~0 o4 C, K- Z# _
3. Return e raised to the power of x.
   
4. 
   ! X7 w6 A, K* S; {0 Z; P2 `$ ~; `5 |
5. >>> math.exp(1)
   
6. 2.718281828459045
   ! C6 S3 k7 C; u0 n1 C2 o
7. >>> math.exp(2)
   " z- m8 F' l# ~" `
8. 7.38905609893065
   
9. >>> math.exp(3)
   
10. 20.085536923187668

复制代码

math.expm1(x)  返回math.e的x(其值为2.71828)次方的值减１

1. #返回math.e的x(其值为2.71828)次方的值减１
   : J8 N5 {" C' P5 Y3 ~2 c. y
2. expm1(x)
   + @0 N- z/ w' U' }5 H. ~
3. Return exp(x)-1.
   
4. This function avoids the loss of precision involved in the direct evaluation of exp(x)-1 for small x.
   2 h9 K7 F0 m0 V' r6 ~# l& n
5. 
   6 ^! u* v7 i+ L1 [" Z4 I$ n
6. >>> math.expm1(1)
   1 Z# ]) s  ?4 L3 a2 g5 r4 k
7. 1.718281828459045
     D8 ]4 \0 f) t8 ~
8. >>> math.expm1(2)
   
9. 6.38905609893065
   $ [3 \' P) l  M# q% n
10. >>> math.expm1(3)
    
11. 19.085536923187668

复制代码

math.fabs(x)  返回x的绝对值
+ K+ A; j1 H3 t9 J  ^' h) c

1. #返回x的绝对值
   . P- d" c) f" y
2. fabs(x)
   $ o$ R( [0 I/ I8 ^. x
3. Return the absolute value of the float x.
   & h0 L$ u1 m+ x# V( H0 r
4. 
   
5. >>> math.fabs(-0.003)
   
6. 0.003
   
7. >>> math.fabs(-110)
   * U# b5 {7 l+ D
8. 110.0
   
9. >>> math.fabs(100)
   
10. 100.0

复制代码

: }8 x7 A6 |2 W* m8 T& `' Zmath.factorial(x)  取x的阶乘的值
% p; x, v# K0 p% L& T& v. ^

1. #取x的阶乘的值
   0 i4 n9 d! v7 v# C. e4 f9 R
2. factorial(x) -> Integral
   
3. Find x!. Raise a ValueError if x is negative or non-integral.
   
4. >>> math.factorial(1)
   
5. 1
   - `+ i" s3 K; S& ~8 Z# r
6. >>> math.factorial(2)
   5 M: {7 O9 H$ ^& x3 G" ?2 J% W
7. 2
   8 O, W0 b( I* F8 `5 u! h% f* R
8. >>> math.factorial(3)
   & T3 \7 E9 d! e! B/ ?, s0 {/ Q
9. 6
   
10. >>> math.factorial(5)
    
11. 120
    
12. >>> math.factorial(10)
    
13. 3628800

复制代码

math.fmod(x,y)  得到x/y的余数，其值是一个浮点数

1. #得到x/y的余数，其值是一个浮点数
   
2. fmod(x, y)
   ) r: V0 [3 `; Y+ V# c" H- M
3. Return fmod(x, y), according to platform C.  x % y may differ.
   $ ^$ R1 [9 h0 M  s: N  f
4. >>> math.fmod(20,3)
     ]0 R" Z" V9 m" z( Z# k
5. 2.0
   
6. >>> math.fmod(20,7)
   
7. 6.0

复制代码

" j5 `2 [! S% ]0 Vmath.frexp(x)  返回一个元组(m,e),其计算方式为：x分别除0.5和1,得到一个值的范围
: _+ f7 h6 `' j1 @, O0 J) o

1. #返回一个元组(m,e),其计算方式为：x分别除0.5和1,得到一个值的范围，
   9 w4 \( j; c% G+ e8 W
2. #2**e的值在这个范围内，e取符合要求的最大整数值,然后x/(2**e),得到m的值
   3 Y6 X8 ]" a( L; A6 n: L% k2 K# F. \
3. #如果x等于0,则m和e的值都为0,m的绝对值的范围为(0.5,1)之间，不包括0.5和1
   
4. frexp(x)
   
5. Return the mantissa and exponent of x, as pair (m, e).
   
6. m is a float and e is an int, such that x = m * 2.**e.
   
7. If x is 0, m and e are both 0.  Else 0.5 <= abs(m) < 1.0.
   : k" o# a, L" u4 {' O1 W
8. >>> math.frexp(10)
   
9. (0.625, 4)
   7 _( p! s5 T3 k+ f. n1 j
10. >>> math.frexp(75)
    
11. (0.5859375, 7)
    2 V- t3 q6 L9 S5 [. s, K/ n- L- @
12. >>> math.frexp(-40)
    
13. (-0.625, 6)
    / p4 N, e/ s6 K* ]: s- @" M9 }4 C# P
14. >>> math.frexp(-100)
    ' e% m7 P8 w6 @/ u9 N
15. (-0.78125, 7)
    7 i. t" G% m5 [9 \% _0 C
16. >>> math.frexp(100)
    
17. (0.78125, 7)

复制代码

1 J) o1 o6 I- V3 smath.fsum(seq)  对迭代器里的每个元素进行求和操作（注：seq 代表 序列）
% _; [: H0 z4 P, T- z

1. #对迭代器里的每个元素进行求和操作
   
2. fsum(iterable)
   : K+ q+ F9 P# c* w4 w9 E7 C+ a4 b
3. Return an accurate floating point sum of values in the iterable.
   8 U8 w: w4 G, K4 m2 b6 w) }
4. Assumes IEEE-754 floating point arithmetic.
   & X+ F; N  T9 v1 I: D8 U" o  Q: y* v
5. >>> math.fsum([1,2,3,4])
   9 w" ?6 U' u3 q% C0 A
6. 10.0
   # M+ H- b- H, J! l& p
7. >>> math.fsum((1,2,3,4))
   & j$ ~% n) W$ r+ c% ~1 X; v
8. 10.0
   
9. >>> math.fsum((-1,-2,-3,-4))
   ; [% O, p8 T( o
10. -10.0
    
11. >>> math.fsum([-1,-2,-3,-4])
    
12. -10.0

复制代码

; c$ s7 q# a; f5 j% Ymath.gcd(x,y)  返回x和y的最大公约数
% L. ^8 @( x2 T

1. #返回x和y的最大公约数
   6 w9 K- f5 c- g1 `$ J
2. gcd(x, y) -> int
   
3. greatest common divisor of x and y
   
4. >>> math.gcd(8,6)
   ( ~# G8 M4 Z$ C( S3 U2 {) |
5. 2
   5 `0 T/ y! [% P! X. ~. a. k
6. >>> math.gcd(40,20)
   
7. 20
   ! e/ ^# t3 [, R3 l+ K$ v
8. >>> math.gcd(8,12)
   , {- i. n; |5 m
9. 4

复制代码

) O& j7 Q+ O8 q" d9 D$ u: Y. Wmath.hypot(x,y)  如果x是不是无穷大的数字,则返回True,否则返回False

1. #得到(x**2+y**2),平方的值
   
2. hypot(x, y)
   
3. Return the Euclidean distance, sqrt(x*x + y*y).
   6 C& `  e9 j" o
4. >>> math.hypot(3,4)
   ! L; s: e) Y3 x2 M8 g6 [* R, g
5. 5.0
   
6. >>> math.hypot(6,8)
   7 W; [5 U2 U+ ]
7. 10.0

复制代码

math.isfinite()  如果x是正无穷大或负无穷大，则返回True,否则返回False
( D" H: {: ?4 B5 _; j8 i- S

1. #如果x是不是无穷大的数字,则返回True,否则返回False
   
2. isfinite(x) -> bool
   " X( M9 t( M0 E
3. Return True if x is neither an infinity nor a NaN, and False otherwise.
   
4. >>> math.isfinite(100)
   2 O# ~* g, V. {5 X. U
5. True
   
6. >>> math.isfinite(0)
   
7. True
   1 F6 J7 F2 r- T% F: B+ |$ N' y
8. >>> math.isfinite(0.1)
   
9. True
   
10. >>> math.isfinite("a")
    6 B+ `# S. w7 W7 {' ~% A
11. >>> math.isfinite(0.0001)
    0 K; Q6 h0 a" T1 x4 g3 _# R2 y
12. True

复制代码

. n) U' e4 k1 E0 _: Gmath.isinf(x)  如果x是正无穷大或负无穷大，则返回True,否则返回False

1. #如果x是正无穷大或负无穷大，则返回True,否则返回False
   
2. isinf(x) -> bool
   
3. Return True if x is a positive or negative infinity, and False otherwise.
   
4. >>> math.isinf(234)
   * E  N( U: J( {+ {" i: ~
5. False
   
6. >>> math.isinf(0.1)
   
7. False

复制代码

6 l/ Q" ]% B! I& x, I1 T* Omath.isnan(x)  如果x不是数字True,否则返回False
4 F: B- g6 l; _5 u& r

1. #如果x不是数字True,否则返回False
   
2. isnan(x) -> bool
   
3. Return True if x is a NaN (not a number), and False otherwise.
   
4. >>> math.isnan(23)
   1 d4 R% r* {2 u' ?6 T  a& P
5. False
   
6. >>> math.isnan(0.01)
   
7. False

复制代码

math.ldexp(x,i)  返回x*(2**i)的值

1. #返回x*(2**i)的值
   7 n  C  b. J$ X9 {. a1 U
2. ldexp(x, i)
   
3. Return x * (2**i).
   
4. >>> math.ldexp(5,5)
   
5. 160.0
   * l2 y3 Q0 k* z- @0 {9 ]
6. >>> math.ldexp(3,5)
   
7. 96.0

复制代码

math.log10(x)  返回x的以10为底的对数
) e/ \( M5 T  t4 B* \

1. #返回x的以10为底的对数
   
2. log10(x)
   
3. Return the base 10 logarithm of x.
   5 Q2 Y/ F/ K- f- q0 J
4. >>> math.log10(10)
   # d: Y7 O& b. P3 a- \
5. 1.0
   7 T+ L# J/ L3 C  Z+ X+ n
6. >>> math.log10(100)
   - ]7 _7 Y8 n  N: e; V/ m4 F
7. 2.0
   
8. #即10的1.3次方的结果为20
   
9. >>> math.log10(20)
   
10. 1.3010299956639813

复制代码

/ s0 H3 |$ j' G4 Omath.log1p(x)  返回x+1的自然对数(基数为e)的值

1. #返回x+1的自然对数(基数为e)的值
   9 r5 @2 W; Z; {
2. log1p(x)
   - `; G. Q3 p6 Y+ ?/ u( f
3. Return the natural logarithm of 1+x (base e).
   
4. The result is computed in a way which is accurate for x near zero.
   , i2 k3 l9 v$ V. f* P
5. >>> math.log(10)
   
6. 2.302585092994046
   8 V4 h. R  ~& K0 }  u0 l8 ]* i
7. >>> math.log1p(10)
   
8. 2.3978952727983707
   
9. >>> math.log(11)
   
10. 2.3978952727983707

复制代码

2 f. a! i! L+ V/ b. dmath.log2(x)  返回x的基2对数
7 w! [% B0 C+ ?! t; [

1. #返回x的基2对数
   , S7 A+ @6 {6 d
2. log2(x)
   2 ^' B6 n5 K8 T' ^1 \- A2 L0 k
3. Return the base 2 logarithm of x.
   
4. >>> math.log2(32)
   ) X: `1 Y6 b! {% x6 ?; [, y( p% H
5. 5.0
   / ]* z/ W/ X- c; |
6. >>> math.log2(20)
   
7. 4.321928094887363
   # g' p# w0 b/ T* u! Y+ B( \
8. >>> math.log2(16)
   
9. 4.0

复制代码

  w% E. E: O% Y; Emath.modf(x)  返回由x的小数部分和整数部分组成的元组
; a& N4 M8 d4 O

1. #返回由x的小数部分和整数部分组成的元组
   9 f  R! C9 ]5 Y' C$ \% L
2. modf(x)
   . E& U3 r4 a& g0 Y7 N, U/ J
3. Return the fractional and integer parts of x.  Both results carry the sign
   , s+ @- ?( {6 E
4. of x and are floats.
   
5. >>> math.modf(math.pi)
   
6. (0.14159265358979312, 3.0)
   - A6 L! V) W6 W! U6 V7 R
7. >>> math.modf(12.34)
   
8. (0.33999999999999986, 12.0)

复制代码

  A0 |; U6 G5 W" q# a- Y1 jmath.sqrt(x)  求x的平方根

1. #求x的平方根
   
2. sqrt(x)
   
3. Return the square root of x.
   
4. >>> math.sqrt(100)
   
5. 10.0
   
6. >>> math.sqrt(16)
   
7. 4.0
   ! C' C6 V9 O. T7 b1 S# t
8. >>> math.sqrt(20)
   
9. 4.47213595499958

复制代码

+ W5 Y7 j: H7 }, Y7 Hmath.trunc(x)  返回x的整数部分

1. #返回x的整数部分
   
2. trunc(x:Real) -> Integral
   ' @+ \, G! Z+ l5 n  ~; j
3. Truncates x to the nearest Integral toward 0. Uses the __trunc__ magic method.
   
4. >>> math.trunc(6.789)
   7 @/ K# R; i& ]' f: z1 s
5. 6
   4 a1 k3 r. ]+ C
6. >>> math.trunc(math.pi)
   + U. b$ v' i( t7 k3 X( h6 f! c, l
7. 3
   7 {( |+ h$ B# ]+ h( A0 `. Z% R
8. >>> math.trunc(2.567)
   
9. 2

复制代码

注：其中蓝色字体部分是高中需要掌握的基本语法