, _" V3 [, E2 m; Z' U' ?【注意】在使用之前，必须先导入math模块，以开方函数 sqrt 为例，介绍2种引入方式及各自使用方法。

$ q$ ?& C; r- y, ~7 ]方法1：
' j9 O: K3 B. U9 s1 b

1. >>> import math
   
2. >>> math.sqrt(9)
   
3. 3.0

复制代码

方法2：

1. >>> from math import sqrt
   $ X* d  m9 h2 `4 V# f/ e
2. >>> sqrt(9)
   : w0 ]$ z! n6 V3 a& x, c
3. 3.0

复制代码

- F$ U- V7 C0 _  e7 x. m: M: _% s

---

math.e  表示一个常量

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

复制代码

: E) m( `$ r- V; V) m1 [math.pi  数字常量，圆周率

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

复制代码

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

1. #取大于等于x的最小的整数值，如果x是一个整数，则返回x
   
2. ceil(x)
   - n0 x/ \7 Y( N, b5 i  n
3. Return the ceiling of x as an int.
   + R( v/ J. J- q; [  {' {. H
4. This is the smallest integral value >= x.
   2 |- t+ u$ r2 G2 I8 K" v& n
5. 
   $ s, z" I5 {) I  L/ g: V
6. >>> math.ceil(4.01)
   
7. 5
   9 \1 f  H  E; P% k+ m, f4 D
8. >>> math.ceil(4.99)
   
9. 5
   
10. >>> math.ceil(-3.99)
    
11. -3
    
12. >>> math.ceil(-3.01)
    0 F3 c, m2 v0 \% h- y4 C, }
13. -3

复制代码

6 P" p5 y, W9 q8 A7 V& F  T, @math.floor(x)  取小于等于x的最大的整数值，如果x是一个整数，则返回自身

1. #取小于等于x的最大的整数值，如果x是一个整数，则返回自身
   
2. floor(x)
   
3. Return the floor of x as an int.
   0 n# Q0 y  v% w: ~- w
4. This is the largest integral value <= x.
   
5. >>> math.floor(4.1)
   
6. 4
   9 h/ Z; `% {6 E$ t8 ?7 E9 o
7. >>> math.floor(4.999)
   
8. 4
   
9. >>> math.floor(-4.999)
   ' S8 |7 v2 r* z7 Y, @& {8 Q& i
10. -5
    8 b, n. O) c$ `/ F* F
11. >>> math.floor(-4.01)
    - z" X% ]# R& D2 k0 R
12. -5

复制代码

- @. Y3 C+ p# t& J" Omath.pow(x,y)  返回x的y次方，即x**y

1. #返回x的y次方，即x**y
   
2. pow(x, y)
   
3. Return x**y (x to the power of y).
   
4. >>> math.pow(3,4)
   ' z& Y3 T% b( n9 R7 ~2 _
5. 81.0
   5 o2 K& a8 _$ ^7 s% A9 R  J
6. >>>
   
7. >>> math.pow(2,7)
   
8. 128.0

复制代码

math.log(x)  返回x的自然对数，默认以e为基数，base参数给定时，将x的对数返回给定的base，计算式为：log(x)/log(base)
  x; U% d) x# [2 v; \: f1 l: W

1. #返回x的自然对数，默认以e为基数，base参数给定时，将x的对数返回给定的base,计算式为：log(x)/log(base)
   
2. log(x[, base])
   9 k5 c- Y9 j6 L/ j1 t2 e
3. Return the logarithm of x to the given base.
   
4. If the base not specified, returns the natural logarithm (base e) of x.
   2 |- m$ }$ B, N+ @. m1 V5 O- k
5. >>> math.log(10)
   2 ~& i5 b, [  r7 V  b
6. 2.302585092994046
   
7. >>> math.log(11)
   2 {/ Z7 m3 T& q3 ~; c5 m8 s6 g; J
8. 2.3978952727983707
   & a8 y, U! C( }8 C0 @. I1 _* Q$ V; ]
9. >>> math.log(20)
   
10. 2.995732273553991

复制代码

math.sin(x)  求x(x为弧度)的正弦值
! V8 V  F" i! v9 v/ `* [1 Z

1. #求x(x为弧度)的正弦值
   : ]- Q2 P- j2 C0 B- T5 m. K
2. sin(x)
     R& _: W; w+ e1 e
3. Return the sine of x (measured in radians).
   & ?( f0 o: |2 Y& K
4. >>> math.sin(math.pi/4)
   
5. 0.7071067811865475
   9 p) r6 d. a; r; n4 [' E
6. >>> math.sin(math.pi/2)
   
7. 1.0
   
8. >>> math.sin(math.pi/3)
   
9. 0.8660254037844386

复制代码

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

1. #求x的余弦，x必须是弧度
   
2. cos(x)
   8 f2 {* R/ s) j9 g. _( u
3. Return the cosine of x (measured in radians).
   
4. #math.pi/4表示弧度，转换成角度为45度
   
5. >>> math.cos(math.pi/4)
   
6. 0.7071067811865476
   
7. math.pi/3表示弧度，转换成角度为60度
   
8. >>> math.cos(math.pi/3)
   , h' m: i1 e' x6 W( W/ w
9. 0.5000000000000001
   . a% b9 B& g" E7 h; }" W" e: z
10. math.pi/6表示弧度，转换成角度为30度
    
11. >>> math.cos(math.pi/6)
    
12. 0.8660254037844387

复制代码

math.tan(x)  返回x(x为弧度)的正切值

1. #返回x(x为弧度)的正切值
   
2. tan(x)
   + h7 u( ~2 P- r# N& n
3. Return the tangent of x (measured in radians).
   4 u1 P0 ]! c0 a) D8 [3 X* l+ q& p
4. >>> math.tan(math.pi/4)
   
5. 0.9999999999999999
   # u) o0 v0 r' k5 `/ k* @0 y2 [  f
6. >>> math.tan(math.pi/6)
   
7. 0.5773502691896257
   
8. >>> math.tan(math.pi/3)
   
9. 1.7320508075688767

复制代码

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

1. #把x从弧度转换成角度
   ; r' [! d! ]3 _* g) U
2. degrees(x)
   2 M% V. Q  K+ I" L+ {! j- L
3. Convert angle x from radians to degrees.
   2 h0 M. B0 C8 }4 Q
4. 
   & T5 u  x; a3 ~2 p4 J+ k" g
5. >>> math.degrees(math.pi/4)
   4 B0 B/ [+ d. w2 V
6. 45.0
   
7. >>> math.degrees(math.pi)
   
8. 180.0
   + \' Q4 T6 S6 S1 N0 }3 u
9. >>> math.degrees(math.pi/6)
   
10. 29.999999999999996
    
11. >>> math.degrees(math.pi/3)
    
12. 59.99999999999999

复制代码

math.radians(x)  把角度x转换成弧度
. p2 d6 n  K2 a3 X" y

1. #把角度x转换成弧度
   
2. radians(x)
   ) h6 b2 T) f0 O8 D
3. Convert angle x from degrees to radians.
   9 O' X- W* }8 O5 T# U
4. >>> math.radians(45)
   5 B+ L1 |0 @' ~' {2 b# V+ C9 {6 V
5. 0.7853981633974483
   0 Q0 S' m3 N) c/ Q* j' _
6. >>> math.radians(60)
   
7. 1.0471975511965976

复制代码

math.copysign(x,y)  把y的正负号加到x前面，可以使用0
7 G. c3 |$ B  `2 E3 _1 ]+ M: D

1. #把y的正负号加到x前面，可以使用0
   # ?) L, c4 I2 e* ^
2. copysign(x, y)
   6 B$ N+ f4 Q* |7 E, f1 ^; E3 k
3. Return a float with the magnitude (absolute value) of x but the sign
   : D- @5 O( o- O0 i; c
4. of y. On platforms that support signed zeros, copysign(1.0, -0.0)
   
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)
    
12. 3.0
    - ]3 H( M# |- F4 j: ~/ I
13. >>> math.copysign(3,-8)
    
14. -3.0

复制代码

/ M/ i. A% u" }6 d. nmath.exp(x)  返回math.e,也就是2.71828的x次方

1. #返回math.e,也就是2.71828的x次方
   
2. exp(x)
     ^$ D/ C3 Q0 G6 h5 }
3. Return e raised to the power of x.
   ! Y1 I0 g2 k/ B) ~; O5 }! U8 y
4. 
   # R$ \+ t+ w. C5 h$ c
5. >>> math.exp(1)
   
6. 2.718281828459045
     Q- ]$ m7 Y( J1 w- t' ^0 d
7. >>> math.exp(2)
   
8. 7.38905609893065
   5 K7 ?+ {6 q, C
9. >>> math.exp(3)
   7 S9 v6 \) t4 T7 o( [1 z
10. 20.085536923187668

复制代码

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

1. #返回math.e的x(其值为2.71828)次方的值减１
   
2. expm1(x)
   " m9 A2 J- f' c; w5 Q* 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.
   / O6 Q4 e* h3 {
5. 
   * u6 b' d/ V: E2 j
6. >>> math.expm1(1)
   , i% g2 x  [- K6 x4 [  Y
7. 1.718281828459045
   . e7 }8 j- v* Z5 u0 y& P! \! s: ]" O
8. >>> math.expm1(2)
   * V+ ?- Q4 m" c4 N0 r! v1 U, s+ M
9. 6.38905609893065
   
10. >>> math.expm1(3)
    ) W1 f9 _3 c- K: c
11. 19.085536923187668

复制代码

math.fabs(x)  返回x的绝对值

1. #返回x的绝对值
   
2. fabs(x)
   
3. Return the absolute value of the float x.
   
4. 
   . `+ [. S6 e1 v: T6 W. w9 Q
5. >>> math.fabs(-0.003)
   2 ~( l- D' P& t- A8 S  r3 o7 b5 ^" P
6. 0.003
   / f5 c$ w+ @2 B# N& U' n
7. >>> math.fabs(-110)
   # c% h, N3 r+ W  G
8. 110.0
   0 D; ^0 O1 v' l4 w+ v
9. >>> math.fabs(100)
   
10. 100.0

复制代码

math.factorial(x)  取x的阶乘的值
0 x$ q& C% {9 S) W* I

1. #取x的阶乘的值
   8 t  O2 ~% C4 W
2. factorial(x) -> Integral
   
3. Find x!. Raise a ValueError if x is negative or non-integral.
   # J6 R. K" r7 P  p0 I
4. >>> math.factorial(1)
   " s0 _: B" P6 Z1 M4 v6 [
5. 1
   - R8 A1 D) G/ @6 [
6. >>> math.factorial(2)
   
7. 2
   
8. >>> math.factorial(3)
   
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)
   & ~4 u0 P5 x& y8 q+ _6 ^- T
3. Return fmod(x, y), according to platform C.  x % y may differ.
   
4. >>> math.fmod(20,3)
   5 D# y3 n* ]1 _% l3 j: e* W
5. 2.0
   $ G+ }8 G9 Z/ f5 T  |. N0 R
6. >>> math.fmod(20,7)
   , l* N3 A2 ~  Q: \( F% {; C
7. 6.0

复制代码

math.frexp(x)  返回一个元组(m,e),其计算方式为：x分别除0.5和1,得到一个值的范围

1. #返回一个元组(m,e),其计算方式为：x分别除0.5和1,得到一个值的范围，
   - c5 @/ ]6 F" I  g% o. M
2. #2**e的值在这个范围内，e取符合要求的最大整数值,然后x/(2**e),得到m的值
   
3. #如果x等于0,则m和e的值都为0,m的绝对值的范围为(0.5,1)之间，不包括0.5和1
   : v% g: B: n: F/ M
4. frexp(x)
   
5. Return the mantissa and exponent of x, as pair (m, e).
   6 d( o- ~+ M" b- L' p/ U1 x
6. m is a float and e is an int, such that x = m * 2.**e.
   & G8 I# H. d) w2 n: K
7. If x is 0, m and e are both 0.  Else 0.5 <= abs(m) < 1.0.
   9 H- t4 y$ c7 z+ J& k
8. >>> math.frexp(10)
   3 f. T4 G3 V7 l4 `- C& w8 b4 r
9. (0.625, 4)
   
10. >>> math.frexp(75)
    ' Q. O* k+ a# l
11. (0.5859375, 7)
    4 h: r5 e) E" h5 Y8 R
12. >>> math.frexp(-40)
    
13. (-0.625, 6)
      l( |/ @" q! p3 v, a
14. >>> math.frexp(-100)
    ( \* c1 K5 g0 t/ M- e' G1 `% t' U% g
15. (-0.78125, 7)
    . J9 _6 \. F' h
16. >>> math.frexp(100)
    + p3 u+ C1 F' S4 f: _
17. (0.78125, 7)

复制代码

math.fsum(seq)  对迭代器里的每个元素进行求和操作（注：seq 代表 序列）
# k7 |; W) B6 y% _9 h2 G7 }0 h

1. #对迭代器里的每个元素进行求和操作
   + q. l  F, P# L- Z% Y3 @: j
2. fsum(iterable)
   7 {# P' U- N) ]3 {2 i
3. Return an accurate floating point sum of values in the iterable.
   2 r8 L# {' I1 @; F0 n: u- f
4. Assumes IEEE-754 floating point arithmetic.
   ( Y) J- D, q8 y0 }
5. >>> math.fsum([1,2,3,4])
   
6. 10.0
   ( s5 v: T; P! r! r$ H/ v& j3 Y
7. >>> math.fsum((1,2,3,4))
   6 g" j: X! k% P( S( i
8. 10.0
   
9. >>> math.fsum((-1,-2,-3,-4))
   
10. -10.0
    
11. >>> math.fsum([-1,-2,-3,-4])
    
12. -10.0

复制代码

$ j) F2 W- f: Z0 G! \( xmath.gcd(x,y)  返回x和y的最大公约数
# f- S+ a9 p/ j

1. #返回x和y的最大公约数
   
2. gcd(x, y) -> int
   4 Y, x: m$ V# H% G: p0 [
3. greatest common divisor of x and y
   
4. >>> math.gcd(8,6)
   . E' ]" e$ H  X- Y5 x! V
5. 2
   $ C# \4 w; u5 x* S2 V5 q+ |
6. >>> math.gcd(40,20)
   
7. 20
   # Z6 j3 Z( Y1 F: u1 n
8. >>> math.gcd(8,12)
   % Q" q8 V1 s$ t! s/ F
9. 4

复制代码

1 h/ L3 ?6 R$ J3 u7 omath.hypot(x,y)  如果x是不是无穷大的数字,则返回True,否则返回False
4 g5 u$ u0 b; L# @& {; J! s

1. #得到(x**2+y**2),平方的值
   
2. hypot(x, y)
     F+ ~  h- W( G4 P+ h" P' j: y" }
3. Return the Euclidean distance, sqrt(x*x + y*y).
   
4. >>> math.hypot(3,4)
   1 C- h5 J( ]0 Y8 \8 j0 S' Q" B* Z% V
5. 5.0
   7 ]& Q. h* Y0 ~
6. >>> math.hypot(6,8)
   : E* _9 [# x1 L1 M+ Y2 t
7. 10.0

复制代码

! _- ^* D( e; P4 ?1 D) Omath.isfinite()  如果x是正无穷大或负无穷大，则返回True,否则返回False
! i  W5 O, V( l. T- t" _+ m

1. #如果x是不是无穷大的数字,则返回True,否则返回False
   . _! d6 j  d5 M5 z) t
2. isfinite(x) -> bool
   . k+ U" u6 y, f9 p; N4 @* c
3. Return True if x is neither an infinity nor a NaN, and False otherwise.
   
4. >>> math.isfinite(100)
   1 [1 X. Q5 J5 p. ]# G4 p
5. True
   . I1 ]" x5 g! l) v# q" `& ?6 T
6. >>> math.isfinite(0)
   8 w6 J1 X+ n( n0 q8 p8 T
7. True
   0 y6 M) @9 T; q7 V
8. >>> math.isfinite(0.1)
   , b7 z, \7 H/ x+ r3 E
9. True
   + e6 O) i$ B1 q, ~
10. >>> math.isfinite("a")
    
11. >>> math.isfinite(0.0001)
    + L: f- \7 c* {$ X9 n
12. True

复制代码

0 q# H; f( p0 k9 d5 a. vmath.isinf(x)  如果x是正无穷大或负无穷大，则返回True,否则返回False
/ R7 H6 x% j9 r: t% `

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)
   . r& P1 N" E5 p2 |( }6 G
5. False
   ) j: Z  X  v2 g  X; k4 B
6. >>> math.isinf(0.1)
   
7. False

复制代码

math.isnan(x)  如果x不是数字True,否则返回False
4 W' v* }% y$ {' Z& t

1. #如果x不是数字True,否则返回False
   & z2 |: h4 P+ V1 z* @
2. isnan(x) -> bool
   
3. Return True if x is a NaN (not a number), and False otherwise.
   
4. >>> math.isnan(23)
   
5. False
   ) R0 R+ N  a% e3 K
6. >>> math.isnan(0.01)
   
7. False

复制代码

1 t- e1 F" m# _1 T; Zmath.ldexp(x,i)  返回x*(2**i)的值
* ^  i* q% U$ o9 f

1. #返回x*(2**i)的值
   
2. ldexp(x, i)
   
3. Return x * (2**i).
   
4. >>> math.ldexp(5,5)
   
5. 160.0
   7 d' p8 l( F; u7 m2 f7 P
6. >>> math.ldexp(3,5)
   
7. 96.0

复制代码

" L5 [$ I; e- zmath.log10(x)  返回x的以10为底的对数

1. #返回x的以10为底的对数
   / p% A% ?" H& X9 P
2. log10(x)
   - x5 F" x0 H' X# C2 K" M2 d' N
3. Return the base 10 logarithm of x.
   
4. >>> math.log10(10)
   ( j1 R- E5 M& @0 |0 I# d- W
5. 1.0
   ) x* k& F3 D( C  I4 k
6. >>> math.log10(100)
   8 L$ J4 U5 j: v: _
7. 2.0
   : J, O! H5 n" o1 @1 C
8. #即10的1.3次方的结果为20
   
9. >>> math.log10(20)
   2 D" f1 K7 Q. C6 Q% l/ r: `
10. 1.3010299956639813

复制代码

math.log1p(x)  返回x+1的自然对数(基数为e)的值
( {& ?; g+ |& w  w3 R6 g

1. #返回x+1的自然对数(基数为e)的值
   - i- H* o! e9 r3 S- y% y
2. log1p(x)
   
3. Return the natural logarithm of 1+x (base e).
   4 W' Z$ D" f% \# r  w2 `
4. The result is computed in a way which is accurate for x near zero.
   & f' N' C( `' r  x! k5 F! H+ w0 q3 }& W
5. >>> math.log(10)
   5 s  r& s% E2 i0 W; _
6. 2.302585092994046
   : r9 O# N9 p' `2 Y7 [, I! [5 x
7. >>> math.log1p(10)
     n0 O/ z& t  h( }2 M; c" B( m! f' e
8. 2.3978952727983707
   
9. >>> math.log(11)
   
10. 2.3978952727983707

复制代码

$ R2 o4 r. F% ^4 E0 \math.log2(x)  返回x的基2对数

1. #返回x的基2对数
   
2. log2(x)
   
3. Return the base 2 logarithm of x.
   $ c4 U, P- R8 P
4. >>> math.log2(32)
   . o- w" m) Z( e8 L
5. 5.0
   
6. >>> math.log2(20)
   5 [2 r5 J( x- N* u1 b) U
7. 4.321928094887363
   
8. >>> math.log2(16)
   7 c3 h8 z; ]" v( h; e
9. 4.0

复制代码

) g7 V7 t4 ]5 f& @math.modf(x)  返回由x的小数部分和整数部分组成的元组
+ s& I' Z% }9 u$ l& P) [6 T4 u" h

1. #返回由x的小数部分和整数部分组成的元组
   ; K/ U8 K' E. N% V# @2 c* y
2. modf(x)
   
3. Return the fractional and integer parts of x.  Both results carry the sign
   / y# w& z6 j" s# P7 \
4. of x and are floats.
   & N3 e) H/ R1 z
5. >>> math.modf(math.pi)
   9 D7 g/ n& ?  _4 W6 w7 N
6. (0.14159265358979312, 3.0)
   
7. >>> math.modf(12.34)
   
8. (0.33999999999999986, 12.0)

复制代码

0 ~6 M# \$ C1 V' Y% ?' D6 y" ]math.sqrt(x)  求x的平方根

1. #求x的平方根
   
2. sqrt(x)
   3 A" p1 N, R5 d: ^/ r5 `
3. Return the square root of x.
   - s! i/ N/ n1 g" _& t( w; w/ }7 e  |
4. >>> math.sqrt(100)
   
5. 10.0
   9 l8 L1 {! k: i( a& }7 i! Z
6. >>> math.sqrt(16)
   
7. 4.0
   
8. >>> math.sqrt(20)
   & C  Y- P5 O! `$ m4 ]* p! c0 x( q) `
9. 4.47213595499958

复制代码

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

1. #返回x的整数部分
   
2. trunc(x:Real) -> Integral
   * x: i4 \! _8 K7 S/ R+ ^
3. Truncates x to the nearest Integral toward 0. Uses the __trunc__ magic method.
   - a" P$ U6 Y7 D6 E; B7 j
4. >>> math.trunc(6.789)
   ) `1 `. N& e6 W! I: B! [, u
5. 6
   ! @+ [3 d) l; ^; q# W
6. >>> math.trunc(math.pi)
   2 h" T+ I8 j$ R" D
7. 3
   
8. >>> math.trunc(2.567)
     O: B" Z' V! u" ^/ f8 C$ z8 `! U
9. 2

复制代码

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