【注意】在使用之前，必须先导入math模块，以开方函数 sqrt 为例，介绍2种引入方式及各自使用方法。
, Q$ `5 ]9 m  ~4 T
# M4 K( F. ]. t$ U- q6 T/ T5 d, Y% \方法1：
7 H; O) h( N; M

1. >>> import math
   0 K1 R+ Q/ |" C9 N( U1 e
2. >>> math.sqrt(9)
   
3. 3.0

复制代码

方法2：

1. >>> from math import sqrt
   
2. >>> sqrt(9)
   2 ?& s$ A$ m  P7 R7 ]0 `
3. 3.0

复制代码

---

math.e  表示一个常量

1. #表示一个常量
   
2. >>> math.e
   7 k4 f0 c5 z) e9 B% f: n/ x8 J
3. 2.718281828459045

复制代码

6 b) @/ {$ b* w& l2 qmath.pi  数字常量，圆周率

1. #数字常量，圆周率
   5 V; ?" m, l$ @/ t1 Y$ E: N
2. >>> print(math.pi)
   " s1 F) a3 b# _5 }2 ?* j: [
3. 3.141592653589793

复制代码

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

1. #取大于等于x的最小的整数值，如果x是一个整数，则返回x
   
2. ceil(x)
   
3. Return the ceiling of x as an int.
   5 H8 M% ^! e" K8 Z
4. This is the smallest integral value >= x.
   
5. 
   4 Z7 M. y9 i2 N) C7 R
6. >>> math.ceil(4.01)
   
7. 5
   
8. >>> math.ceil(4.99)
   
9. 5
   / C* ]9 `0 @4 }- v) x+ I
10. >>> math.ceil(-3.99)
    
11. -3
    
12. >>> math.ceil(-3.01)
    ) k. [& J$ n! K( k
13. -3

复制代码

( r- b3 w( V9 Q& b  Hmath.floor(x)  取小于等于x的最大的整数值，如果x是一个整数，则返回自身
: d) j8 E$ F4 g' B( R& c2 P

1. #取小于等于x的最大的整数值，如果x是一个整数，则返回自身
   
2. floor(x)
   , ?; c! I$ [4 S# a3 _- n# S
3. Return the floor of x as an int.
   
4. This is the largest integral value <= x.
   
5. >>> math.floor(4.1)
   
6. 4
   " Y! t6 C% P( R$ r) X8 h" R
7. >>> math.floor(4.999)
   0 G1 E0 {$ [; G& l: N/ ^2 M
8. 4
   ) t$ L- G) x. W7 l8 L! D
9. >>> math.floor(-4.999)
   % K8 a* T% d  }0 [6 c9 A
10. -5
    6 N. K8 \. o" h( w) a$ |/ ^0 s
11. >>> math.floor(-4.01)
    ) k( y- B( C+ ]6 e
12. -5

复制代码

5 o2 d$ x4 U! d0 h; g/ _math.pow(x,y)  返回x的y次方，即x**y
: H9 U& \# R5 a, h

1. #返回x的y次方，即x**y
   
2. pow(x, y)
   # ]) l* y- i1 m& R
3. Return x**y (x to the power of y).
   " `" Q% X3 R* Z9 K
4. >>> math.pow(3,4)
   1 g- S% x" e6 g9 s
5. 81.0
   ( C! J7 v2 m) U5 l" Y  ~& r. m
6. >>>
   
7. >>> math.pow(2,7)
     X: |' @- B. c. R- |5 t
8. 128.0

复制代码

math.log(x)  返回x的自然对数，默认以e为基数，base参数给定时，将x的对数返回给定的base，计算式为：log(x)/log(base)

1. #返回x的自然对数，默认以e为基数，base参数给定时，将x的对数返回给定的base,计算式为：log(x)/log(base)
   
2. log(x[, base])
   % y$ Q  a. O" V3 E/ o7 L% X' f8 Q
3. Return the logarithm of x to the given base.
   $ }$ v% U. L5 H- v
4. If the base not specified, returns the natural logarithm (base e) of x.
   
5. >>> math.log(10)
   
6. 2.302585092994046
   
7. >>> math.log(11)
   ' r; b& o. L4 s' j
8. 2.3978952727983707
   3 m9 T. t8 m% Q
9. >>> math.log(20)
   * Q! b9 C8 z* [( F: l
10. 2.995732273553991

复制代码

/ I  F$ M9 V: f! x/ h* dmath.sin(x)  求x(x为弧度)的正弦值

1. #求x(x为弧度)的正弦值
   
2. sin(x)
   
3. Return the sine of x (measured in radians).
   $ ^4 D" Z8 e! B( R) o* ?
4. >>> math.sin(math.pi/4)
   ( o( x% l1 R8 Y6 B
5. 0.7071067811865475
   
6. >>> math.sin(math.pi/2)
   3 M, V& O( h+ M5 f: k3 I
7. 1.0
   
8. >>> math.sin(math.pi/3)
   7 M( b  z" d' d4 y: N2 o. C
9. 0.8660254037844386

复制代码

; E9 b: g8 F; z' Hmath.cos(x)  求x的余弦，x必须是弧度

1. #求x的余弦，x必须是弧度
   / d1 e# ?3 r' v  n, r
2. cos(x)
   0 D# P2 {9 [7 |: y0 b
3. Return the cosine of x (measured in radians).
   * z3 H. j. K$ l# E4 Y& s& V
4. #math.pi/4表示弧度，转换成角度为45度
   ( z0 g. U, \- b9 D" F9 `
5. >>> math.cos(math.pi/4)
   $ O4 x. V  Q/ l  c& u4 s
6. 0.7071067811865476
   
7. math.pi/3表示弧度，转换成角度为60度
   / I7 V4 ^; m6 a( t2 Z" s
8. >>> math.cos(math.pi/3)
   $ k. U; P' i9 [+ e7 [! p
9. 0.5000000000000001
   
10. math.pi/6表示弧度，转换成角度为30度
    * n6 {, Q  T; T: a* j- u
11. >>> math.cos(math.pi/6)
    - Y( }$ u- k! Y
12. 0.8660254037844387

复制代码

. X) C1 Q7 s% r6 `math.tan(x)  返回x(x为弧度)的正切值
0 C/ }% Y2 w* G. S0 J

1. #返回x(x为弧度)的正切值
   
2. tan(x)
   
3. Return the tangent of x (measured in radians).
   4 z- {8 [/ o- _
4. >>> math.tan(math.pi/4)
   1 g/ h( b. _! D$ B, Q9 g8 `5 q* J* E
5. 0.9999999999999999
   
6. >>> math.tan(math.pi/6)
   $ I$ `( n9 u' U) J* T2 h; X
7. 0.5773502691896257
   4 k% b$ c. R: W$ r
8. >>> math.tan(math.pi/3)
   
9. 1.7320508075688767

复制代码

4 y, f4 h5 M) w9 ]6 h& Pmath.degrees(x)  把x从弧度转换成角度
. o, C2 R) u5 D; ]& Z# G  ]

1. #把x从弧度转换成角度
   % O; {% _% J7 q2 a+ h5 a1 y( i: k3 h
2. degrees(x)
   
3. Convert angle x from radians to degrees.
   - P+ f+ F9 m3 G( w6 @3 d5 y
4. 
   
5. >>> math.degrees(math.pi/4)
   & `6 S$ ^* W. G4 h
6. 45.0
   ) h; m: C8 _0 S* ?+ W. E
7. >>> math.degrees(math.pi)
   
8. 180.0
   6 |3 ~- J2 G% v4 \
9. >>> math.degrees(math.pi/6)
   # u' s2 l5 l1 N2 G4 {
10. 29.999999999999996
    
11. >>> math.degrees(math.pi/3)
    
12. 59.99999999999999

复制代码

- o4 J# }2 B  T3 Y* i0 q* H7 K# Ymath.radians(x)  把角度x转换成弧度

1. #把角度x转换成弧度
   2 @& l! C1 x: ]  E# V
2. radians(x)
   , a2 Y+ d) ]' B" a+ Z
3. Convert angle x from degrees to radians.
   
4. >>> math.radians(45)
   
5. 0.7853981633974483
   + c5 i+ V" I" ?7 ^' r  `
6. >>> math.radians(60)
   / Q6 o7 j. t" D3 ]
7. 1.0471975511965976

复制代码

" f" g4 |: U/ b% R: Q' u0 Mmath.copysign(x,y)  把y的正负号加到x前面，可以使用0
9 g: |! H9 g, P, a

1. #把y的正负号加到x前面，可以使用0
   ' _  a, k7 c4 L4 K4 s8 t& B
2. copysign(x, y)
   
3. Return a float with the magnitude (absolute value) of x but the sign
   0 y2 ]$ t% y% f, l
4. of y. On platforms that support signed zeros, copysign(1.0, -0.0)
   8 |% u  J1 \& \3 e; k
5. returns -1.0.
   ' r" o! ^' o2 u: t1 m: o7 F1 T7 ?
6. 
   ! g# a* h* T: {" [1 O1 S' C# ]
7. >>> math.copysign(2,3)
   
8. 2.0
   
9. >>> math.copysign(2,-3)
   
10. -2.0
    
11. >>> math.copysign(3,8)
    
12. 3.0
    
13. >>> math.copysign(3,-8)
    
14. -3.0

复制代码

7 {' O% D' K9 U& A2 g( U6 pmath.exp(x)  返回math.e,也就是2.71828的x次方

1. #返回math.e,也就是2.71828的x次方
   
2. exp(x)
   3 i0 K; t# w5 |6 l
3. Return e raised to the power of x.
   
4. 
   ! O* F& W! N9 w9 a
5. >>> math.exp(1)
   
6. 2.718281828459045
   0 E) E5 x% {- L5 d$ X3 ~2 l! ?
7. >>> math.exp(2)
   4 U" z& k3 ~( v
8. 7.38905609893065
   3 [0 j/ E6 |% x( a4 E
9. >>> math.exp(3)
   1 _9 ^' E& k1 Y
10. 20.085536923187668

复制代码

math.expm1(x)  返回math.e的x(其值为2.71828)次方的值减１
' |+ F1 x2 P* v8 r7 Y2 j  Y" O& \

1. #返回math.e的x(其值为2.71828)次方的值减１
   
2. expm1(x)
   8 N# n( U) ?/ a: X5 k7 z/ I
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. 
   , d. F( N5 o' S0 G$ o$ `
6. >>> math.expm1(1)
   , Q& ?" b( w* i" @* u  _/ [8 E; c6 l2 Z/ Z
7. 1.718281828459045
   
8. >>> math.expm1(2)
   
9. 6.38905609893065
   8 ~9 N: c+ T9 O* ~' v! {
10. >>> math.expm1(3)
    % D/ K0 I" e) M, |( ?6 G! r
11. 19.085536923187668

复制代码

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

1. #返回x的绝对值
   
2. fabs(x)
   
3. Return the absolute value of the float x.
   
4. 
     P6 }5 p  ]" }9 M; Z/ u
5. >>> math.fabs(-0.003)
   3 [" c* x* y8 C2 l9 P
6. 0.003
   9 I+ U. s: M2 T: C
7. >>> math.fabs(-110)
   . g: _5 x0 e! X9 N' W& n# m3 b" B+ u
8. 110.0
   7 S/ R9 v5 i# F6 f& r: R0 W$ G
9. >>> math.fabs(100)
     F; E* B5 |* w7 i
10. 100.0

复制代码

math.factorial(x)  取x的阶乘的值
) r  G) H4 y+ \& t5 w

1. #取x的阶乘的值
   
2. factorial(x) -> Integral
   
3. Find x!. Raise a ValueError if x is negative or non-integral.
   
4. >>> math.factorial(1)
   # _$ I, k& y# b! {' w
5. 1
   
6. >>> math.factorial(2)
   
7. 2
   
8. >>> math.factorial(3)
   6 \7 r# }$ n1 H2 r
9. 6
   
10. >>> math.factorial(5)
    ; X8 `5 Y" }7 A! P
11. 120
    
12. >>> math.factorial(10)
    % ~8 o7 u6 f+ I) h) G+ B  w
13. 3628800

复制代码

math.fmod(x,y)  得到x/y的余数，其值是一个浮点数
% o; [7 b6 N  P2 F/ W9 S: @

1. #得到x/y的余数，其值是一个浮点数
   - {7 W0 q4 }: x( l" f) D9 m4 o
2. fmod(x, y)
   
3. Return fmod(x, y), according to platform C.  x % y may differ.
   . j' M& r; M4 S2 _7 |& z
4. >>> math.fmod(20,3)
   7 p# b2 w( z, I' i5 b$ r. l4 R
5. 2.0
   
6. >>> math.fmod(20,7)
   6 i% c9 W9 K0 n& @
7. 6.0

复制代码

math.frexp(x)  返回一个元组(m,e),其计算方式为：x分别除0.5和1,得到一个值的范围
( N( L: F- t% X4 f8 `6 i' w

1. #返回一个元组(m,e),其计算方式为：x分别除0.5和1,得到一个值的范围，
   
2. #2**e的值在这个范围内，e取符合要求的最大整数值,然后x/(2**e),得到m的值
   : Z" Q) d% l; A5 `
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).
   " l- O$ a* l0 E8 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.
   % j% L( n2 A0 L. w0 h
8. >>> math.frexp(10)
   
9. (0.625, 4)
   - `0 i& I) u& M: o: L0 B) L
10. >>> math.frexp(75)
      a' }: F" p' G! U* }
11. (0.5859375, 7)
    
12. >>> math.frexp(-40)
    , v& M) z: \9 ]! Z% Z! C' e4 G1 S
13. (-0.625, 6)
    % |/ L: [8 W- p& C% c& E5 h
14. >>> math.frexp(-100)
    
15. (-0.78125, 7)
    
16. >>> math.frexp(100)
    
17. (0.78125, 7)

复制代码

math.fsum(seq)  对迭代器里的每个元素进行求和操作（注：seq 代表 序列）

1. #对迭代器里的每个元素进行求和操作
   
2. fsum(iterable)
   - i/ _) l8 ~; _( \
3. Return an accurate floating point sum of values in the iterable.
   & k- ~2 H7 Y  X: N
4. Assumes IEEE-754 floating point arithmetic.
   6 O( D( P; i1 G: z: P5 o
5. >>> math.fsum([1,2,3,4])
   6 s: g  b8 b2 E
6. 10.0
   , R( ?/ C9 f6 q7 x: X
7. >>> math.fsum((1,2,3,4))
   3 Y) Q1 z- ?& P  l
8. 10.0
   
9. >>> math.fsum((-1,-2,-3,-4))
   ! t$ W5 s. S. F
10. -10.0
    , W7 Z! G: J( G+ c
11. >>> math.fsum([-1,-2,-3,-4])
    / s0 }8 |' C1 d( Z6 k
12. -10.0

复制代码

( _# Y+ {+ G* P% a2 x; U3 Ymath.gcd(x,y)  返回x和y的最大公约数

1. #返回x和y的最大公约数
   
2. gcd(x, y) -> int
   
3. greatest common divisor of x and y
   * k7 G, U" p8 z3 F" O; ~$ u
4. >>> math.gcd(8,6)
   ; d1 s* W: ~$ F8 b% p6 f0 J# b
5. 2
   
6. >>> math.gcd(40,20)
   1 v0 b  c6 v( `9 W
7. 20
   
8. >>> math.gcd(8,12)
   
9. 4

复制代码

math.hypot(x,y)  如果x是不是无穷大的数字,则返回True,否则返回False
5 d) k% f8 m0 w( P, M

1. #得到(x**2+y**2),平方的值
   # f" W, p9 R5 i: B
2. hypot(x, y)
   - e; t5 K# J9 _2 y$ O! H
3. Return the Euclidean distance, sqrt(x*x + y*y).
   
4. >>> math.hypot(3,4)
   + P; x8 j. z- S! e/ ?! Z
5. 5.0
   8 ?& p9 d& d  `# `; ~4 [0 v3 M/ K
6. >>> math.hypot(6,8)
   
7. 10.0

复制代码

math.isfinite()  如果x是正无穷大或负无穷大，则返回True,否则返回False
1 s. P  A0 |" ~8 W' P" l

1. #如果x是不是无穷大的数字,则返回True,否则返回False
     |/ E# X) f; I% Q, H7 h/ R) p8 u
2. isfinite(x) -> bool
   3 U# ]  q  h  f+ S' c
3. Return True if x is neither an infinity nor a NaN, and False otherwise.
   9 f5 P4 f9 O1 M( U! M
4. >>> math.isfinite(100)
   ; F3 i8 ~" a: f8 m2 w! X4 O6 J
5. True
   ' x% u( l4 q9 [" Z4 o6 s
6. >>> math.isfinite(0)
   
7. True
   4 U: [5 f* c; F  a" I/ v
8. >>> math.isfinite(0.1)
   
9. True
   
10. >>> math.isfinite("a")
      O4 t& a' [$ z- _: G# Z
11. >>> math.isfinite(0.0001)
    
12. True

复制代码

math.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)
   ' \( F% y9 `4 Q' I( Q1 M' U$ W3 Z; E
5. False
   : ~5 C: a6 q- o6 d+ S" }
6. >>> math.isinf(0.1)
   
7. False

复制代码

math.isnan(x)  如果x不是数字True,否则返回False

1. #如果x不是数字True,否则返回False
   - k9 p7 o( G$ [6 k
2. isnan(x) -> bool
   
3. Return True if x is a NaN (not a number), and False otherwise.
   
4. >>> math.isnan(23)
   
5. False
   
6. >>> math.isnan(0.01)
   ) `6 T1 H; h) \3 {$ ^8 X
7. False

复制代码

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

1. #返回x*(2**i)的值
   / \& t- j. A; S) Y1 o% J3 a3 Y  \
2. ldexp(x, i)
   
3. Return x * (2**i).
   1 a( u6 a5 g2 |. e& g2 J$ [
4. >>> math.ldexp(5,5)
   ! x1 K" T- x9 f& `! p9 R  k" \
5. 160.0
   
6. >>> math.ldexp(3,5)
   ( _* C; o0 j2 H% J( S) t) z
7. 96.0

复制代码

math.log10(x)  返回x的以10为底的对数
( q; H: Z2 M2 A3 a- n

1. #返回x的以10为底的对数
   7 d' Z* I: w+ h9 a4 d6 M: _& H. [
2. log10(x)
   $ ?9 ]. F1 F, d; q
3. Return the base 10 logarithm of x.
   / |- Y  ~- \  O
4. >>> math.log10(10)
   
5. 1.0
   
6. >>> math.log10(100)
   ' d0 U; R* c6 ~4 @1 R* Q
7. 2.0
   
8. #即10的1.3次方的结果为20
   % O( V8 Y: C4 g6 L0 A
9. >>> math.log10(20)
   1 Q: m$ M) I2 r1 l. m3 M
10. 1.3010299956639813

复制代码

" l) v" `' H6 C& W0 d8 W3 t1 W0 w; G6 rmath.log1p(x)  返回x+1的自然对数(基数为e)的值

1. #返回x+1的自然对数(基数为e)的值
   , m& {) y: Y$ n$ b: e! ?
2. log1p(x)
   " R( I) ?8 S. Z! R, [3 b
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)
   
6. 2.302585092994046
   
7. >>> math.log1p(10)
   
8. 2.3978952727983707
   
9. >>> math.log(11)
   : b; u, x; s8 E6 D1 s/ S
10. 2.3978952727983707

复制代码

math.log2(x)  返回x的基2对数
  _9 v! \: H! Y; [

1. #返回x的基2对数
   
2. log2(x)
   
3. Return the base 2 logarithm of x.
   ( ?; Y/ g5 s  a% d  B% M' p
4. >>> math.log2(32)
   
5. 5.0
   
6. >>> math.log2(20)
   
7. 4.321928094887363
   
8. >>> math.log2(16)
   
9. 4.0

复制代码

2 {% h; d- d, ]' l" i6 \9 rmath.modf(x)  返回由x的小数部分和整数部分组成的元组
; D. l( @. }# I7 D  l

1. #返回由x的小数部分和整数部分组成的元组
   6 \; {8 o9 U6 i6 R: M
2. modf(x)
   
3. Return the fractional and integer parts of x.  Both results carry the sign
   % T0 V, S7 D4 ~8 c# T7 Z
4. of x and are floats.
   
5. >>> math.modf(math.pi)
   % D' }2 S# J* g4 I) S/ L
6. (0.14159265358979312, 3.0)
   1 n$ e! b0 m6 _
7. >>> math.modf(12.34)
   
8. (0.33999999999999986, 12.0)

复制代码

$ t! w8 _- C1 h4 M6 K3 Wmath.sqrt(x)  求x的平方根
* }1 U# j/ \/ K

1. #求x的平方根
   6 @- Z# h% o6 G. o
2. sqrt(x)
   
3. Return the square root of x.
   
4. >>> math.sqrt(100)
   
5. 10.0
   / l! `8 @4 M  n1 p
6. >>> math.sqrt(16)
   & D, E3 l& g7 g; m/ s6 {4 o, t
7. 4.0
   
8. >>> math.sqrt(20)
   * d) G& G# x& k. q) q, p
9. 4.47213595499958

复制代码

/ H9 J3 [( o: @" r. vmath.trunc(x)  返回x的整数部分

1. #返回x的整数部分
   
2. trunc(x:Real) -> Integral
   * R/ C- h1 o' G9 g& L( {) V
3. Truncates x to the nearest Integral toward 0. Uses the __trunc__ magic method.
   ' {+ a" B/ u' W4 t$ c6 ^: c; ~' ]
4. >>> math.trunc(6.789)
   ; ~2 Y  P- A. O/ x( z
5. 6
   
6. >>> math.trunc(math.pi)
   ( O. U- w6 P6 T
7. 3
   
8. >>> math.trunc(2.567)
   3 V0 S8 s+ n% h) R2 C
9. 2

复制代码

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