* @9 E2 s$ T$ V0 @4 P【注意】在使用之前，必须先导入math模块，以开方函数 sqrt 为例，介绍2种引入方式及各自使用方法。

5 ]/ g$ z; U6 p8 w, F8 M* m, A方法1：

1. >>> import math
   
2. >>> math.sqrt(9)
   ' |# V- M  [, M: e7 ~
3. 3.0

复制代码

方法2：
7 S0 ^# [9 E! i3 M+ G  Y# U

1. >>> from math import sqrt
   
2. >>> sqrt(9)
   9 v3 X  K" i0 J( F5 U
3. 3.0

复制代码

---

math.e  表示一个常量

1. #表示一个常量
   6 H( _1 J- G8 ]3 k1 N: x' V
2. >>> math.e
   - d: P/ t, ~2 ]' ^& T" Z
3. 2.718281828459045

复制代码

math.pi  数字常量，圆周率

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

复制代码

math.ceil(x)  取大于等于x的最小的整数值，如果x是一个整数，则返回x

1. #取大于等于x的最小的整数值，如果x是一个整数，则返回x
   
2. ceil(x)
   * ?& k1 f2 \' p! ?+ M' \1 `! K
3. Return the ceiling of x as an int.
   
4. This is the smallest integral value >= x.
   ; ?  [5 p. m' V1 v
5. 
   
6. >>> math.ceil(4.01)
   ' r$ P7 N! V1 s- A
7. 5
   $ b' A8 M0 }; m. |( h
8. >>> math.ceil(4.99)
   ( _- |6 H* O+ a
9. 5
   
10. >>> math.ceil(-3.99)
    " A5 K6 d  P/ a- N( h
11. -3
    
12. >>> math.ceil(-3.01)
    
13. -3

复制代码

: X, n: V/ P. b: J: H" Pmath.floor(x)  取小于等于x的最大的整数值，如果x是一个整数，则返回自身
$ H# ~" _( t- r- w! }& b

1. #取小于等于x的最大的整数值，如果x是一个整数，则返回自身
     D& Z! T1 x6 |9 t+ M. Q% s4 P# b1 u
2. floor(x)
   
3. Return the floor of x as an int.
   
4. This is the largest integral value <= x.
   , t2 `2 m9 r' o; D8 N
5. >>> math.floor(4.1)
   8 B( p5 G: `% O" ^$ G" A5 _3 X7 J
6. 4
   
7. >>> math.floor(4.999)
   ( y* ?8 {; x4 h' M0 Z
8. 4
   ) v9 |9 H* c: n+ f0 S4 C+ N0 C
9. >>> math.floor(-4.999)
   ) G% ]) x, R; ^/ P4 `" i9 e
10. -5
    
11. >>> math.floor(-4.01)
    
12. -5

复制代码

math.pow(x,y)  返回x的y次方，即x**y
! q- |0 @  e9 `/ N$ e6 M

1. #返回x的y次方，即x**y
   ) G5 f* U2 P- p! Y! M
2. pow(x, y)
   3 I, P; d( j" X, V8 w; g+ R0 T
3. Return x**y (x to the power of y).
   
4. >>> math.pow(3,4)
   
5. 81.0
   ( N$ C) f/ d, F
6. >>>
   
7. >>> math.pow(2,7)
   9 }' |# F. N, k% W6 e: c
8. 128.0

复制代码

. X) f% M) y& q0 z5 s9 q$ Q, W) b5 n; Imath.log(x)  返回x的自然对数，默认以e为基数，base参数给定时，将x的对数返回给定的base，计算式为：log(x)/log(base)
6 G; @# ]) P, p) b0 Z

1. #返回x的自然对数，默认以e为基数，base参数给定时，将x的对数返回给定的base,计算式为：log(x)/log(base)
   / c% p$ T. `$ r" p' K
2. log(x[, base])
   
3. Return the logarithm of x to the given base.
   
4. If the base not specified, returns the natural logarithm (base e) of x.
   
5. >>> math.log(10)
   0 L( C7 b7 ?& G5 ]! H8 R6 u5 ?
6. 2.302585092994046
   
7. >>> math.log(11)
   $ `% G9 a# V' N& ]! F
8. 2.3978952727983707
   4 U2 N  o) E- K3 t* t$ A# J' a
9. >>> math.log(20)
   
10. 2.995732273553991

复制代码

math.sin(x)  求x(x为弧度)的正弦值

1. #求x(x为弧度)的正弦值
   $ y: x$ J% w6 D
2. sin(x)
   " \  k: V9 @8 h
3. Return the sine of x (measured in radians).
   
4. >>> math.sin(math.pi/4)
   
5. 0.7071067811865475
   
6. >>> math.sin(math.pi/2)
   0 N+ q' r# ^; c7 a2 A- p
7. 1.0
   ; [( O+ A2 |7 {7 p% a2 n( V. R  @
8. >>> math.sin(math.pi/3)
   1 m5 f+ C& d; x: W( V
9. 0.8660254037844386

复制代码

math.cos(x)  求x的余弦，x必须是弧度
& b2 I& }, M1 s; D: v8 N7 `  g

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)
   & C+ Q& i, {6 Q7 T
6. 0.7071067811865476
   ! r; Y$ K/ v. d1 ^
7. math.pi/3表示弧度，转换成角度为60度
   
8. >>> math.cos(math.pi/3)
   4 ?) U7 U6 u( _1 i/ P! J# ~/ F) i
9. 0.5000000000000001
   ! S9 }3 n" G$ T+ U' ?( F
10. math.pi/6表示弧度，转换成角度为30度
    
11. >>> math.cos(math.pi/6)
    
12. 0.8660254037844387

复制代码

9 e9 m! U  N$ I) {. @$ l; N! R$ G* mmath.tan(x)  返回x(x为弧度)的正切值
7 V# u; P0 u0 ^5 C, e3 k

1. #返回x(x为弧度)的正切值
   . f* R. C. |. L3 m1 W
2. tan(x)
   " U1 k: E* h- t  B* F- k
3. Return the tangent of x (measured in radians).
   
4. >>> math.tan(math.pi/4)
   + e! Y) y1 B1 U' N* I9 l9 F2 o- q* V
5. 0.9999999999999999
   
6. >>> math.tan(math.pi/6)
   
7. 0.5773502691896257
   
8. >>> math.tan(math.pi/3)
   
9. 1.7320508075688767

复制代码

math.degrees(x)  把x从弧度转换成角度

1. #把x从弧度转换成角度
   % J8 c$ O, L  ?  ?9 C  `6 {! y& X
2. degrees(x)
   
3. Convert angle x from radians to degrees.
   4 ~  r, T5 [4 D# P: ]) x( y' n* Q
4. 
   $ d% J- x# R- C# Z  j1 t
5. >>> math.degrees(math.pi/4)
   % I$ v5 Z( S& _, m" L2 T4 B* `7 T
6. 45.0
   4 A3 X' h  X4 w! w) C! G
7. >>> math.degrees(math.pi)
   
8. 180.0
   
9. >>> math.degrees(math.pi/6)
   % H1 J( z/ c8 ]9 i/ h
10. 29.999999999999996
    7 C& f4 K8 x3 M( o" k8 C
11. >>> math.degrees(math.pi/3)
    , m  S- W) j2 ]4 p
12. 59.99999999999999

复制代码

math.radians(x)  把角度x转换成弧度
& [) \; ^" Q+ X$ c# X

1. #把角度x转换成弧度
   
2. radians(x)
   
3. Convert angle x from degrees to radians.
   
4. >>> math.radians(45)
   
5. 0.7853981633974483
   - \& k  a; B/ G0 o, k. l. p- |4 k
6. >>> math.radians(60)
   
7. 1.0471975511965976

复制代码

+ r* u+ [6 K( wmath.copysign(x,y)  把y的正负号加到x前面，可以使用0

1. #把y的正负号加到x前面，可以使用0
   6 q% E3 `% L  l6 {' P, N
2. copysign(x, y)
   # [3 B# @. `5 v& J" s
3. Return a float with the magnitude (absolute value) of x but the sign
   ! E  @. W1 f# v8 ^3 v
4. of y. On platforms that support signed zeros, copysign(1.0, -0.0)
   
5. returns -1.0.
   
6. 
   ' n5 v5 o6 `( _; T( b
7. >>> math.copysign(2,3)
   1 e# f) }' s0 A
8. 2.0
   
9. >>> math.copysign(2,-3)
   . N" A  x2 ~( Y( t
10. -2.0
    1 m" i2 w; j; H. ?5 }7 ~6 c
11. >>> math.copysign(3,8)
    
12. 3.0
    4 x+ {8 F7 C, f7 ^9 X
13. >>> math.copysign(3,-8)
    
14. -3.0

复制代码

) c( l- M% R2 w1 r  pmath.exp(x)  返回math.e,也就是2.71828的x次方
( E; ~8 q/ i8 \/ X  S. L

1. #返回math.e,也就是2.71828的x次方
   $ j! i8 Z2 B$ N) S( X; ?& D
2. exp(x)
   
3. Return e raised to the power of x.
   4 [, i& y6 Z* P/ Z- X# M+ {# ]& \
4. 
   
5. >>> math.exp(1)
   
6. 2.718281828459045
   3 M4 r! s0 ^+ i& u
7. >>> math.exp(2)
   
8. 7.38905609893065
   4 K# H% e1 s2 I/ L  T! n
9. >>> math.exp(3)
   
10. 20.085536923187668

复制代码

. h' V& c6 T+ z" d& _math.expm1(x)  返回math.e的x(其值为2.71828)次方的值减１
! b- B7 C" s3 a( E. X$ a; D

1. #返回math.e的x(其值为2.71828)次方的值减１
   
2. expm1(x)
   # J3 T& _1 C8 i% M; J; q6 h5 G4 Q
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.
   
5. 
   
6. >>> math.expm1(1)
   
7. 1.718281828459045
   . V3 r  F5 ^+ i0 D/ G3 [
8. >>> math.expm1(2)
   
9. 6.38905609893065
   
10. >>> math.expm1(3)
    
11. 19.085536923187668

复制代码

6 P0 _) _, C2 c5 Kmath.fabs(x)  返回x的绝对值

1. #返回x的绝对值
   
2. fabs(x)
   0 ~0 E- Z/ D* e
3. Return the absolute value of the float x.
   
4. 
   ) J2 D0 [8 C8 |9 B, K
5. >>> math.fabs(-0.003)
   
6. 0.003
   2 R/ A% S0 r% e7 ~+ |! d
7. >>> math.fabs(-110)
   $ x. r$ ?' e) x4 W5 ~, @( S( J
8. 110.0
   
9. >>> math.fabs(100)
   $ e' T1 T" f  o5 k. j9 j* w( Y6 G
10. 100.0

复制代码

2 Z5 q! K+ g& Z2 s( pmath.factorial(x)  取x的阶乘的值
: w' U0 |. Z) U2 q

1. #取x的阶乘的值
     c9 L/ J' Y  w; l2 o9 B/ y( b- g9 m2 b
2. factorial(x) -> Integral
   
3. Find x!. Raise a ValueError if x is negative or non-integral.
   5 K# y7 h& K% F% r( L' G
4. >>> math.factorial(1)
   : T4 K1 _/ ]+ v# n( G
5. 1
   
6. >>> math.factorial(2)
   
7. 2
   " m! q- V$ \) K+ o
8. >>> math.factorial(3)
   9 D/ ^: F9 X( Z
9. 6
   
10. >>> math.factorial(5)
    
11. 120
    & ?& b( X' h) F& @1 b* h+ Q: J  R
12. >>> math.factorial(10)
    8 ]) S5 p6 t0 S- S
13. 3628800

复制代码

  }' l% G, T; }math.fmod(x,y)  得到x/y的余数，其值是一个浮点数
1 ^) r) ]. f6 N  X, d6 k

1. #得到x/y的余数，其值是一个浮点数
   # }8 k- b; J( w; Y1 t2 p  m4 P
2. fmod(x, y)
   7 |- E1 T. k' i
3. Return fmod(x, y), according to platform C.  x % y may differ.
   7 Q) v  \  y0 \, g: G
4. >>> math.fmod(20,3)
   
5. 2.0
   
6. >>> math.fmod(20,7)
   7 d: ~1 d* a, u4 D+ @5 q6 b
7. 6.0

复制代码

math.frexp(x)  返回一个元组(m,e),其计算方式为：x分别除0.5和1,得到一个值的范围
1 e' t( u7 ^0 {* I+ d+ K

1. #返回一个元组(m,e),其计算方式为：x分别除0.5和1,得到一个值的范围，
   
2. #2**e的值在这个范围内，e取符合要求的最大整数值,然后x/(2**e),得到m的值
   $ o2 T) k! |" G
3. #如果x等于0,则m和e的值都为0,m的绝对值的范围为(0.5,1)之间，不包括0.5和1
   
4. frexp(x)
   % A+ `) Z0 `2 F: G6 c' g
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.
   6 _- z" H3 s( v0 Q7 I5 h% b
8. >>> math.frexp(10)
   4 A" L) F# K# w8 Y
9. (0.625, 4)
   - E& L0 ?! k' k: C: f) Z5 C6 s
10. >>> math.frexp(75)
    - [- [) J' r: }% Z
11. (0.5859375, 7)
    
12. >>> math.frexp(-40)
    . ]( M+ R* p, o2 |
13. (-0.625, 6)
    
14. >>> math.frexp(-100)
    1 ]7 ^2 U/ _9 X2 R1 Q
15. (-0.78125, 7)
    , T8 ]& ]/ Z$ j7 a' w+ z4 J
16. >>> math.frexp(100)
    
17. (0.78125, 7)

复制代码

math.fsum(seq)  对迭代器里的每个元素进行求和操作（注：seq 代表 序列）
  d: L: c3 {( I7 @1 ^6 E: m3 z

1. #对迭代器里的每个元素进行求和操作
   " E/ l+ f" x2 i) Y$ w& l
2. fsum(iterable)
   
3. Return an accurate floating point sum of values in the iterable.
   
4. Assumes IEEE-754 floating point arithmetic.
   7 O( h/ P2 q% @4 r
5. >>> math.fsum([1,2,3,4])
   ( S0 c0 F! ]+ y, e* j
6. 10.0
   # S. s0 {- r. J) T
7. >>> math.fsum((1,2,3,4))
   
8. 10.0
   
9. >>> math.fsum((-1,-2,-3,-4))
   
10. -10.0
    % S- f% h! W1 L' v" R- i
11. >>> math.fsum([-1,-2,-3,-4])
    
12. -10.0

复制代码

math.gcd(x,y)  返回x和y的最大公约数

1. #返回x和y的最大公约数
   
2. gcd(x, y) -> int
   % `: D( |/ Z$ i  f% E: I+ r
3. greatest common divisor of x and y
   : b9 [7 j, z. I5 j! T
4. >>> math.gcd(8,6)
   % s8 _7 n" U  N/ }# s3 p
5. 2
   
6. >>> math.gcd(40,20)
   + R' e: K5 c" z, ?2 c; A
7. 20
   2 I7 H+ b0 y) I. J6 G# b8 D/ I, K
8. >>> math.gcd(8,12)
   
9. 4

复制代码

math.hypot(x,y)  如果x是不是无穷大的数字,则返回True,否则返回False
2 ]0 r4 W* _, j9 d. _  Y

1. #得到(x**2+y**2),平方的值
   
2. hypot(x, y)
   
3. Return the Euclidean distance, sqrt(x*x + y*y).
   3 |; k  T8 G/ x+ w$ e9 n4 p  @. k1 M
4. >>> math.hypot(3,4)
   
5. 5.0
   
6. >>> math.hypot(6,8)
   9 P4 ^$ v% g  T4 o) W, f' s" ^
7. 10.0

复制代码

math.isfinite()  如果x是正无穷大或负无穷大，则返回True,否则返回False
! j# k& x6 n/ G6 D

1. #如果x是不是无穷大的数字,则返回True,否则返回False
   
2. isfinite(x) -> bool
   
3. Return True if x is neither an infinity nor a NaN, and False otherwise.
   ) g. C7 w" v) d
4. >>> math.isfinite(100)
   . l& B; r1 u- I2 G! d5 L8 Q, h
5. True
   
6. >>> math.isfinite(0)
   " u, o1 \! L3 V; x
7. True
   
8. >>> math.isfinite(0.1)
   
9. True
   $ Z1 {: b4 H# O+ T8 n7 J
10. >>> math.isfinite("a")
    % ^/ {& I  E. F1 f
11. >>> math.isfinite(0.0001)
    7 a4 R# z& {! b" g* D7 o6 X
12. True

复制代码

math.isinf(x)  如果x是正无穷大或负无穷大，则返回True,否则返回False
$ I( R9 ]$ B5 B. E9 S2 [- p" g2 f

1. #如果x是正无穷大或负无穷大，则返回True,否则返回False
   ( R! ^! ?6 s, }/ ]2 u
2. isinf(x) -> bool
   
3. Return True if x is a positive or negative infinity, and False otherwise.
   % i, Y8 X) l: Q' ^
4. >>> math.isinf(234)
   
5. False
   
6. >>> math.isinf(0.1)
   " Q  U3 J" T& b: V) ?
7. False

复制代码

math.isnan(x)  如果x不是数字True,否则返回False
! N& q8 V, h' n- z! t& _

1. #如果x不是数字True,否则返回False
   
2. isnan(x) -> bool
   2 w. e+ E. @% C
3. Return True if x is a NaN (not a number), and False otherwise.
   9 Y3 M" r, v0 H" y# O. e; }
4. >>> math.isnan(23)
   
5. False
   $ g- m( {8 ?0 Z/ W1 d3 s/ a
6. >>> math.isnan(0.01)
   
7. False

复制代码

3 s4 [$ T7 f; J0 Tmath.ldexp(x,i)  返回x*(2**i)的值

1. #返回x*(2**i)的值
   $ R: {8 C( W; V( j' m8 G% d: j
2. ldexp(x, i)
   / I; m0 [7 t! p4 r
3. Return x * (2**i).
   2 k- |/ l+ H; ~2 R" o+ h
4. >>> math.ldexp(5,5)
   + R) X$ E8 x) ]! C2 s
5. 160.0
   
6. >>> math.ldexp(3,5)
     S: d. J6 s# [/ F: q
7. 96.0

复制代码

' u. [) y6 l* b8 |: pmath.log10(x)  返回x的以10为底的对数
, v/ o; |  K- R5 f- \

1. #返回x的以10为底的对数
   * [9 }( X) t, [
2. log10(x)
   
3. Return the base 10 logarithm of x.
   " f& n5 z9 g3 q2 H! i7 ^
4. >>> math.log10(10)
   
5. 1.0
   ; f- d" O: M" r0 h2 \# s) `6 b
6. >>> math.log10(100)
   4 \7 d) [* @6 w6 W5 [+ A: h6 O
7. 2.0
   9 r2 }$ `+ w- }5 _' J; N' ?
8. #即10的1.3次方的结果为20
   & d1 S+ o  q" s8 G0 }& M& P
9. >>> math.log10(20)
   7 a# R; p" T/ _/ q
10. 1.3010299956639813

复制代码

( I! x! u9 g7 p( f1 Y* r$ D# Lmath.log1p(x)  返回x+1的自然对数(基数为e)的值
+ |1 l0 x" u* G* X+ ?# J, ?

1. #返回x+1的自然对数(基数为e)的值
   
2. log1p(x)
   ) z& o1 z4 L% c9 U5 ^1 j" G" q
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.
   
5. >>> math.log(10)
   # ]2 U4 N# Q0 i# P! J3 R1 _
6. 2.302585092994046
   6 g- [% T  B- C9 G& e8 W! V$ S
7. >>> math.log1p(10)
   
8. 2.3978952727983707
   
9. >>> math.log(11)
   
10. 2.3978952727983707

复制代码

math.log2(x)  返回x的基2对数

1. #返回x的基2对数
   
2. log2(x)
   
3. Return the base 2 logarithm of x.
   
4. >>> math.log2(32)
   ' X7 L5 S; R) Z3 ?+ V
5. 5.0
   5 F& e- F; h: J! F8 j
6. >>> math.log2(20)
   
7. 4.321928094887363
   : g1 _: P$ E; d) n; k0 [8 e7 m
8. >>> math.log2(16)
   
9. 4.0

复制代码

9 n1 M8 q6 |4 X4 p4 e5 e( Zmath.modf(x)  返回由x的小数部分和整数部分组成的元组
& W( ?0 s( h: u3 c; u

1. #返回由x的小数部分和整数部分组成的元组
   2 b. i9 t, ]" Y8 D; d9 N! m
2. modf(x)
   7 h! l9 s9 l, I, Q0 s& L% _
3. Return the fractional and integer parts of x.  Both results carry the sign
   
4. of x and are floats.
   1 m3 t- ]) K5 T* r2 ]4 y& F
5. >>> math.modf(math.pi)
   
6. (0.14159265358979312, 3.0)
   
7. >>> math.modf(12.34)
   
8. (0.33999999999999986, 12.0)

复制代码

& [& r3 j# V+ m* M# y8 umath.sqrt(x)  求x的平方根
& @' b; n: w3 X& ~

1. #求x的平方根
   ; N% O6 J8 M5 E$ e
2. sqrt(x)
   5 @0 ]( t: q4 v6 P  ~- C% y
3. Return the square root of x.
   : m/ {- I1 Q$ U. n5 ]2 e; ~$ q
4. >>> math.sqrt(100)
   
5. 10.0
   
6. >>> math.sqrt(16)
   : a& J) T( E8 H( p* T, X( ~
7. 4.0
   
8. >>> math.sqrt(20)
   
9. 4.47213595499958

复制代码

math.trunc(x)  返回x的整数部分

1. #返回x的整数部分
   ) z9 q3 ]. \* X" T6 {
2. trunc(x:Real) -> Integral
   
3. Truncates x to the nearest Integral toward 0. Uses the __trunc__ magic method.
   ! h  x2 r$ @# [6 H2 {' p% b+ r/ @
4. >>> math.trunc(6.789)
   
5. 6
   
6. >>> math.trunc(math.pi)
   
7. 3
   ! O. K$ D4 `/ K  d3 q1 ^
8. >>> math.trunc(2.567)
   
9. 2

复制代码

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