. g( @# e0 b0 S; T0 }% n, P; e【注意】在使用之前，必须先导入math模块，以开方函数 sqrt 为例，介绍2种引入方式及各自使用方法。

8 K/ a* T# }8 J. r3 f. f+ ^' |! B7 v6 y方法1：

1. >>> import math
   ' z  W  \( k* ~% v0 i
2. >>> math.sqrt(9)
   
3. 3.0

复制代码

方法2：

1. >>> from math import sqrt
   1 o+ P) D" g" c( {4 Q$ p! l/ V! l
2. >>> sqrt(9)
   
3. 3.0

复制代码

- ^# y* E3 s* x& g& p

---

. u2 k) i1 R# X( k' d4 lmath.e  表示一个常量

1. #表示一个常量
   2 d, A; A1 n8 M4 V7 g8 H4 S) W* \
2. >>> math.e
   
3. 2.718281828459045

复制代码

% F% p0 m6 u; d( q8 y" Rmath.pi  数字常量，圆周率
! N9 D, y) K$ j( T2 f. f2 y

1. #数字常量，圆周率
   9 I, S' Y4 q# r* p
2. >>> print(math.pi)
   
3. 3.141592653589793

复制代码

' z' x, p6 M4 w# k& \math.ceil(x)  取大于等于x的最小的整数值，如果x是一个整数，则返回x
0 T& \' n$ {. b' O! W7 e2 P

1. #取大于等于x的最小的整数值，如果x是一个整数，则返回x
   
2. ceil(x)
   & m6 r8 s: g2 m1 W0 C% f7 Y6 f$ b
3. Return the ceiling of x as an int.
   3 c, p( X# w- Y% c7 K
4. This is the smallest integral value >= x.
   
5. 
   
6. >>> math.ceil(4.01)
   1 b! Q- g# ]; P
7. 5
   
8. >>> math.ceil(4.99)
   
9. 5
   
10. >>> math.ceil(-3.99)
    ! \+ l( b6 S( d  Y$ w+ u/ V( b
11. -3
    
12. >>> math.ceil(-3.01)
      k% m% V" X& w& M9 x
13. -3

复制代码

/ b0 `% w3 x' s! Y# Zmath.floor(x)  取小于等于x的最大的整数值，如果x是一个整数，则返回自身
2 ]- c- c1 l; c0 j4 w# B( w2 a

1. #取小于等于x的最大的整数值，如果x是一个整数，则返回自身
     W" s* u6 Y0 f- \
2. floor(x)
   
3. Return the floor of x as an int.
     e# l* q: ?1 e( D# {/ A2 Y! X
4. This is the largest integral value <= x.
   
5. >>> math.floor(4.1)
   
6. 4
   % r$ n/ X7 A* B) M7 P+ ?* T
7. >>> math.floor(4.999)
   
8. 4
   
9. >>> math.floor(-4.999)
   
10. -5
    
11. >>> math.floor(-4.01)
    
12. -5

复制代码

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

1. #返回x的y次方，即x**y
   
2. pow(x, y)
   0 D7 c5 z/ W- Q' j7 J
3. Return x**y (x to the power of y).
   
4. >>> math.pow(3,4)
   
5. 81.0
     w# u' c5 a' _; x7 s
6. >>>
   
7. >>> math.pow(2,7)
   
8. 128.0

复制代码

math.log(x)  返回x的自然对数，默认以e为基数，base参数给定时，将x的对数返回给定的base，计算式为：log(x)/log(base)
9 U+ `% u7 E* f! C

1. #返回x的自然对数，默认以e为基数，base参数给定时，将x的对数返回给定的base,计算式为：log(x)/log(base)
   
2. log(x[, base])
   ( B. V" \: b& h1 }4 G
3. Return the logarithm of x to the given base.
   ( L+ a+ a7 {, u% o, F( d
4. If the base not specified, returns the natural logarithm (base e) of x.
   : E- \  B9 I7 J' z
5. >>> math.log(10)
   " h; S" C3 d% q: \$ Z7 G7 ^- e
6. 2.302585092994046
   
7. >>> math.log(11)
   : ?% o( }5 x: [: p
8. 2.3978952727983707
   
9. >>> math.log(20)
   4 g) n  e2 V2 f) `" y
10. 2.995732273553991

复制代码

4 d7 n+ U' u4 n9 z1 W* V$ L& wmath.sin(x)  求x(x为弧度)的正弦值
. i4 t4 n% M8 f, e% w, `8 K  V7 ]

1. #求x(x为弧度)的正弦值
   ) e' f1 L' q5 t  B. p# t
2. sin(x)
   
3. Return the sine of x (measured in radians).
   : T2 P$ n$ A! h8 v( b; p9 C# c
4. >>> math.sin(math.pi/4)
     o5 K3 Q2 i$ n( C3 r6 S
5. 0.7071067811865475
   
6. >>> math.sin(math.pi/2)
   0 m7 z! |* \! r3 D5 b
7. 1.0
   
8. >>> math.sin(math.pi/3)
   
9. 0.8660254037844386

复制代码

math.cos(x)  求x的余弦，x必须是弧度
, }& y+ T/ x& e: L& ~

1. #求x的余弦，x必须是弧度
   , f. H& H6 ~9 I% R6 G
2. cos(x)
   
3. Return the cosine of x (measured in radians).
   5 @& V. E. R2 p3 Y
4. #math.pi/4表示弧度，转换成角度为45度
   
5. >>> math.cos(math.pi/4)
   / K+ ^4 d9 y8 b6 U" d7 O# |
6. 0.7071067811865476
   
7. math.pi/3表示弧度，转换成角度为60度
   1 t2 E0 G( S0 u9 \- L& D
8. >>> math.cos(math.pi/3)
   4 O6 G2 v0 l" ]; p
9. 0.5000000000000001
   
10. math.pi/6表示弧度，转换成角度为30度
    
11. >>> math.cos(math.pi/6)
    7 S. M5 F8 i' s3 e8 c0 E- G
12. 0.8660254037844387

复制代码

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

1. #返回x(x为弧度)的正切值
   : |3 t0 O" b2 ]2 ^# r: L
2. tan(x)
   
3. Return the tangent of x (measured in radians).
   
4. >>> math.tan(math.pi/4)
   
5. 0.9999999999999999
   
6. >>> math.tan(math.pi/6)
   % d2 o+ [$ O9 Q# E) b
7. 0.5773502691896257
     D. y7 Q( C5 n& A3 z' D, U
8. >>> math.tan(math.pi/3)
   
9. 1.7320508075688767

复制代码

7 s& H2 a1 z+ m- gmath.degrees(x)  把x从弧度转换成角度

1. #把x从弧度转换成角度
   
2. degrees(x)
   2 S6 C1 [/ V( o
3. Convert angle x from radians to degrees.
   
4. 
   2 c" r" \3 u' B9 c- r
5. >>> math.degrees(math.pi/4)
   
6. 45.0
   9 X- n# M0 ?# V  b/ c# @
7. >>> math.degrees(math.pi)
   
8. 180.0
   
9. >>> math.degrees(math.pi/6)
   : f4 p4 p3 ^0 N) x4 t; u
10. 29.999999999999996
    : |; H/ R4 S7 W
11. >>> math.degrees(math.pi/3)
    " o7 b0 f7 o# \% Z3 [
12. 59.99999999999999

复制代码

: g) D6 d# L4 t3 M3 Omath.radians(x)  把角度x转换成弧度
" Z* [2 w, _( C

1. #把角度x转换成弧度
   ' z0 V6 E' C/ B# J6 P
2. radians(x)
   2 Y) T( B$ {  Z! G: Q
3. Convert angle x from degrees to radians.
   
4. >>> math.radians(45)
   
5. 0.7853981633974483
   
6. >>> math.radians(60)
   1 N( d: T. C% E, ?; W) g
7. 1.0471975511965976

复制代码

" J# a# v$ n6 jmath.copysign(x,y)  把y的正负号加到x前面，可以使用0

1. #把y的正负号加到x前面，可以使用0
   
2. copysign(x, y)
   2 w* J0 q! b0 ]3 a* d# ^% W
3. Return a float with the magnitude (absolute value) of x but the sign
   
4. of y. On platforms that support signed zeros, copysign(1.0, -0.0)
   
5. returns -1.0.
   : g9 _6 c$ ~' Q& C. V
6. 
   & ^$ b: t5 t& w# i
7. >>> math.copysign(2,3)
   
8. 2.0
   
9. >>> math.copysign(2,-3)
   
10. -2.0
    0 ]# c- e3 ^; [- o( h
11. >>> math.copysign(3,8)
    1 B( {: p( _8 L5 V" P6 H# b: R
12. 3.0
    
13. >>> math.copysign(3,-8)
    
14. -3.0

复制代码

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

1. #返回math.e,也就是2.71828的x次方
   
2. exp(x)
   0 W1 h: Q' f- R5 Y' ~, R/ ~$ a
3. Return e raised to the power of x.
   
4. 
   
5. >>> math.exp(1)
   . `9 P0 v: f2 `$ r
6. 2.718281828459045
   6 k) D" T6 x; i6 ?
7. >>> math.exp(2)
   
8. 7.38905609893065
   
9. >>> math.exp(3)
   $ n& b& F) Y8 s  b1 F
10. 20.085536923187668

复制代码

) w( K  W$ n- d5 h" r3 umath.expm1(x)  返回math.e的x(其值为2.71828)次方的值减１

1. #返回math.e的x(其值为2.71828)次方的值减１
   
2. expm1(x)
   
3. Return exp(x)-1.
   7 h2 l) }# _8 u* g3 ?
4. This function avoids the loss of precision involved in the direct evaluation of exp(x)-1 for small x.
   & m1 p/ ?: _' n, ~6 k; U- L! m/ C
5. 
   
6. >>> math.expm1(1)
   9 F4 S% H$ p8 }2 ]! A8 l: n
7. 1.718281828459045
   7 X+ h1 G3 |0 r1 E* V1 A5 G
8. >>> math.expm1(2)
   
9. 6.38905609893065
   
10. >>> math.expm1(3)
    
11. 19.085536923187668

复制代码

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

1. #返回x的绝对值
   ; y& ^8 K( A+ _+ C
2. fabs(x)
   - w0 t4 Z- \& d1 I# N/ t. U
3. Return the absolute value of the float x.
   
4. 
   
5. >>> math.fabs(-0.003)
   
6. 0.003
   
7. >>> math.fabs(-110)
   
8. 110.0
   
9. >>> math.fabs(100)
   4 T  i* c+ i) s
10. 100.0

复制代码

: C. _$ Q3 H6 Qmath.factorial(x)  取x的阶乘的值

1. #取x的阶乘的值
   2 N+ Q+ \0 \3 N1 o6 L9 t0 d. a
2. factorial(x) -> Integral
   ' ]$ r- {" l- o+ L, r
3. Find x!. Raise a ValueError if x is negative or non-integral.
   4 u8 Q/ N) J- o
4. >>> math.factorial(1)
   3 X' `  A9 e# D+ j/ _0 b$ t7 D# _9 E7 N
5. 1
   
6. >>> math.factorial(2)
   
7. 2
   
8. >>> math.factorial(3)
   ' q% ~& a! |* Z
9. 6
   
10. >>> math.factorial(5)
    
11. 120
    / r! Q- }0 i$ R0 L6 Y
12. >>> math.factorial(10)
    ! x, a# P0 }  x8 o% u& }) ^
13. 3628800

复制代码

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

1. #得到x/y的余数，其值是一个浮点数
   
2. fmod(x, y)
   
3. Return fmod(x, y), according to platform C.  x % y may differ.
   5 K6 ]$ ^2 [' D$ ^+ l
4. >>> math.fmod(20,3)
   . f3 G* Q# u5 X
5. 2.0
   
6. >>> math.fmod(20,7)
   . H. U1 ]# Q* u1 E4 z
7. 6.0

复制代码

math.frexp(x)  返回一个元组(m,e),其计算方式为：x分别除0.5和1,得到一个值的范围
; m$ E6 d+ j$ x# C3 l

1. #返回一个元组(m,e),其计算方式为：x分别除0.5和1,得到一个值的范围，
   
2. #2**e的值在这个范围内，e取符合要求的最大整数值,然后x/(2**e),得到m的值
   ) a+ c) e. a& @5 J3 f
3. #如果x等于0,则m和e的值都为0,m的绝对值的范围为(0.5,1)之间，不包括0.5和1
   
4. frexp(x)
   : t+ ~) d, J  r9 N! A8 w0 j
5. Return the mantissa and exponent of x, as pair (m, e).
     c6 O: I3 M* ?! A
6. m is a float and e is an int, such that x = m * 2.**e.
   2 G) N; S) L$ ^) U9 E- S/ e
7. If x is 0, m and e are both 0.  Else 0.5 <= abs(m) < 1.0.
   3 j3 T) E8 D: F" i, m" [$ X
8. >>> math.frexp(10)
   
9. (0.625, 4)
   
10. >>> math.frexp(75)
    % u% M0 I/ `1 ]) e0 x3 X
11. (0.5859375, 7)
    $ f1 }" D* J3 P7 h/ w5 }
12. >>> math.frexp(-40)
    
13. (-0.625, 6)
    # h' O0 C7 S! r. W
14. >>> math.frexp(-100)
    8 Z0 g$ }, z# F0 H9 `3 V
15. (-0.78125, 7)
      s7 g/ U- q& [  l- a0 k2 r. `
16. >>> math.frexp(100)
    
17. (0.78125, 7)

复制代码

% M  A: K5 D% ^  c; r/ lmath.fsum(seq)  对迭代器里的每个元素进行求和操作（注：seq 代表 序列）
1 R  ~) [' L1 c7 q/ D& x3 k' h

1. #对迭代器里的每个元素进行求和操作
   $ ]  L8 Z: s& J- w: b
2. fsum(iterable)
   . J' Q3 o+ g4 q) g
3. Return an accurate floating point sum of values in the iterable.
   
4. Assumes IEEE-754 floating point arithmetic.
   
5. >>> math.fsum([1,2,3,4])
   : G$ Q5 C! o& v; o! f' e- ]
6. 10.0
   $ {8 R& c* ]: }# a
7. >>> math.fsum((1,2,3,4))
   
8. 10.0
   
9. >>> math.fsum((-1,-2,-3,-4))
   
10. -10.0
    
11. >>> math.fsum([-1,-2,-3,-4])
    
12. -10.0

复制代码

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

1. #返回x和y的最大公约数
   % {/ v& j) Q3 C3 U% g6 h* h% T
2. gcd(x, y) -> int
   
3. greatest common divisor of x and y
   
4. >>> math.gcd(8,6)
   5 z1 t3 W4 p* j! t
5. 2
   
6. >>> math.gcd(40,20)
   4 ^1 @8 d+ M9 R
7. 20
   $ e. a6 \5 Q" d
8. >>> math.gcd(8,12)
   " S3 [' ]# q; ?" ]# R: I! r
9. 4

复制代码

math.hypot(x,y)  如果x是不是无穷大的数字,则返回True,否则返回False

1. #得到(x**2+y**2),平方的值
   + H/ P6 M* u/ ]( v! V
2. hypot(x, y)
   
3. Return the Euclidean distance, sqrt(x*x + y*y).
   
4. >>> math.hypot(3,4)
   " r7 M0 t2 w( h$ N
5. 5.0
   
6. >>> math.hypot(6,8)
   
7. 10.0

复制代码

) r+ c6 L) D8 ~3 }7 |8 t' P: }math.isfinite()  如果x是正无穷大或负无穷大，则返回True,否则返回False

1. #如果x是不是无穷大的数字,则返回True,否则返回False
   4 j) o& r& [' A) g- v1 s! M: r
2. isfinite(x) -> bool
   1 X* m4 O2 Q: |9 K
3. Return True if x is neither an infinity nor a NaN, and False otherwise.
   
4. >>> math.isfinite(100)
   8 f) b0 \( T' }( J  u
5. True
   8 [; P9 \9 Y: V8 q7 W) }
6. >>> math.isfinite(0)
   4 N: p; b9 v2 f% d
7. True
     v3 V) h( ~% C6 Y- b) m' P
8. >>> math.isfinite(0.1)
   
9. True
   
10. >>> math.isfinite("a")
    
11. >>> math.isfinite(0.0001)
    
12. True

复制代码

; C% j" R5 i- ^1 H% \/ A$ Nmath.isinf(x)  如果x是正无穷大或负无穷大，则返回True,否则返回False
: b9 [, ]# @; y3 D' D8 V) \$ z

1. #如果x是正无穷大或负无穷大，则返回True,否则返回False
   % @1 }% W2 J# Z2 Y: @
2. isinf(x) -> bool
   7 [& R) A% q+ H  x: g4 _8 [  c
3. Return True if x is a positive or negative infinity, and False otherwise.
   
4. >>> math.isinf(234)
   
5. False
   
6. >>> math.isinf(0.1)
   0 L& r+ E6 s" t) {4 v2 Z( J
7. False

复制代码

6 w4 T! p' {  j  h4 J- imath.isnan(x)  如果x不是数字True,否则返回False
* D+ S3 X- B: }/ [: W( }1 O0 B

1. #如果x不是数字True,否则返回False
   " _1 E& R4 x0 @! f, s, M
2. isnan(x) -> bool
   
3. Return True if x is a NaN (not a number), and False otherwise.
   
4. >>> math.isnan(23)
   
5. False
   + v( Q. ~8 k. J& |3 T5 I
6. >>> math.isnan(0.01)
   
7. False

复制代码

5 T: _0 W) [0 V" m( J: s6 |math.ldexp(x,i)  返回x*(2**i)的值

1. #返回x*(2**i)的值
   ' ~9 C8 U' ^, L# X0 U/ t) U
2. ldexp(x, i)
   
3. Return x * (2**i).
   
4. >>> math.ldexp(5,5)
   
5. 160.0
   $ f. O/ w# b3 a2 x! v) q
6. >>> math.ldexp(3,5)
   2 _. |* t+ P" n( U
7. 96.0

复制代码

math.log10(x)  返回x的以10为底的对数
$ K( M& E; h% X1 U+ U, w$ I6 A

1. #返回x的以10为底的对数
   5 M# e& o5 M$ |8 Z
2. log10(x)
   4 {/ ~* [. T& v+ g+ J' `: z+ R4 E# r
3. Return the base 10 logarithm of x.
   
4. >>> math.log10(10)
   
5. 1.0
   , Z* Y* \. i5 x% ]) s5 a) j
6. >>> math.log10(100)
   
7. 2.0
   ) z6 h$ Z$ L& }2 j+ a
8. #即10的1.3次方的结果为20
   
9. >>> math.log10(20)
   1 M8 k  f  U6 P$ t% u* V& d% R
10. 1.3010299956639813

复制代码

4 K) u' H% `# L1 v2 y) Gmath.log1p(x)  返回x+1的自然对数(基数为e)的值

1. #返回x+1的自然对数(基数为e)的值
   
2. log1p(x)
   6 x& [+ b+ b# ~9 ~$ L/ G' H
3. Return the natural logarithm of 1+x (base e).
   $ V- s$ Z* y0 C% u
4. The result is computed in a way which is accurate for x near zero.
   6 I! w" Q. M1 F  {- E" g( Y
5. >>> math.log(10)
   1 Y9 h2 D# p. H' e
6. 2.302585092994046
   
7. >>> math.log1p(10)
   
8. 2.3978952727983707
   & h. l( r) f3 \# f
9. >>> math.log(11)
   
10. 2.3978952727983707

复制代码

0 O- ]! ^. {1 R/ x, W- L4 _! s0 s( emath.log2(x)  返回x的基2对数

1. #返回x的基2对数
     f8 I# V5 j7 v4 Z  ?% |
2. log2(x)
   9 H) D8 K5 m3 n" u" q
3. Return the base 2 logarithm of x.
   
4. >>> math.log2(32)
   
5. 5.0
   
6. >>> math.log2(20)
   
7. 4.321928094887363
   
8. >>> math.log2(16)
   , j# j& r! a7 i$ _' G
9. 4.0

复制代码

# y7 w* J6 P6 Tmath.modf(x)  返回由x的小数部分和整数部分组成的元组

1. #返回由x的小数部分和整数部分组成的元组
   4 p( |3 D3 f) |. A+ r
2. modf(x)
   
3. Return the fractional and integer parts of x.  Both results carry the sign
   
4. of x and are floats.
   
5. >>> math.modf(math.pi)
   * @- H: e# n# L4 U! x
6. (0.14159265358979312, 3.0)
   ; s8 C4 s: `! F4 J/ L
7. >>> math.modf(12.34)
   
8. (0.33999999999999986, 12.0)

复制代码

math.sqrt(x)  求x的平方根
9 ]0 G2 j. G" P% e1 x; [2 [

1. #求x的平方根
   
2. sqrt(x)
   ) O7 H5 e" M: _1 }
3. Return the square root of x.
   
4. >>> math.sqrt(100)
   
5. 10.0
   
6. >>> math.sqrt(16)
   * ?5 h" f, f7 i
7. 4.0
   + {9 f. @6 }2 ~0 K2 g: f( N" @1 k
8. >>> math.sqrt(20)
   7 M5 d9 }# y# H2 J: x  b  n+ h! C
9. 4.47213595499958

复制代码

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

1. #返回x的整数部分
   + R# l. v" p* b( X& ~
2. trunc(x:Real) -> Integral
   * S: [2 ?. }/ M
3. Truncates x to the nearest Integral toward 0. Uses the __trunc__ magic method.
   * d, E# F9 m9 b5 M  ^; e) \& N
4. >>> math.trunc(6.789)
   , D9 M* a( e' ?8 D
5. 6
   
6. >>> math.trunc(math.pi)
   
7. 3
   , E, L6 r8 C3 d; L
8. >>> math.trunc(2.567)
   ' v0 R7 J7 w: o9 `2 `
9. 2

复制代码

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