Python标准库 —— math库_python math库

math库

说明：此库只用于非复数进行运算，如果想使用负数运算使用cmath库
（闲来无事，把 Python 标准库中 math库搬了一遍，以后也方便检索吧）

1.常量

(1)math.pi

无参数

返回圆周率π的值

import math
print(math.pi)#3.141592653589793
1
2

(2)math.e

无参数

返回自然常数e的值

print(math.e)#2.718281828459045
1

(3)math.tau

无参数

返回二倍圆周率π的值

print(math.tau)#6.283185307179586
1

(4)math.inf

无参数

返回python表示最大值

(5)math.nan

无参数

浮点数的NAN类型,无法被数字表示的类型

2.工具函数

(1)math.ceil(x)

参数x为整数、浮点数

返回返回 x 的向上取整，即大于或等于 x 的最小的整数。

print(math.ceil(3.7))
4
print(math.ceil(3.0))
3
print(math.ceil(-1.2))
-1
1
2
3
4
5
6

(2)math.comb(n,k)

传入参数n,k为非负整数

返回不重复且无顺序地从 n 项中选择 k 项的方式总数。

当 k <= n 时取值为 n! / (k! * (n - k)!)；当 k > n 时取值为零。

也称为二项式系数，因为它等价于表达式 (1 + x) ** n 的多项式展开中第 k 项的系数

print(math.comb(3,2))
print(math.comb(5,3))
1
2

(3)math.copysign(x,y)

传入参数x，y为整数和浮点数

返回一个基于 x 的绝对值和 y 的符号的浮点数。

print(math.copysign(1.0, -0.0))#-1.0
print(math.copysign(1.0,2.0))#1.0
1
2

(4)math.fabs(x)

x为整数、浮点数

返回x的绝对值(浮点数表示)

print(math.fabs(-1))#1.0
print(math.fabs(1))#1.0
1
2

(5)math.factorial(x)

传入非负整数x

返回x的阶乘的值，x!

注:0！ = 1

print(math.factorial(3))#6,3*2*1
1

(6)math.floor(x)

参数x为整数、浮点数

返回返回 x 的向下取整，即小于或等于 x 的最小的整数

print(math.floor(3.5))#3
print(math.floor(3))#3
print(math.floor(-1.2))#-2
1
2
3

(7)math.fmod(x,y)

传入参数x，y为整数或者浮点数

返回x与y的模

注：在整数进行取余时，使用x%y会更好，对于小数使用math.fmod(x,y)会更好。Python的 x % y 返回带有 y 符号的结果，并且可能不能完全计算浮点参数。 例如， fmod(-1e-100, 1e100) 是 -1e-100 ，但Python的 -1e-100 % 1e100 的结果是 1e100-1e-100 ，它不能完全表示为浮点数，并且取整为令人惊讶的 1e100 。

print(math.fmod(4,2))#0.0
print(math.fmod(4,3))#1.0
1
2

(8)math.frexp(x)

传入参数为整数，浮点数

以 (m, e) 对的形式返回 x 的尾数和指数。 m 是一个浮点数， e 是一个整数，正好是 x == m * 2**e 。 如果 x 为零，则返回 (0.0, 0) ，否则返回 0.5 <= abs(m) < 1 。这用于以可移植方式“分离”浮点数的内部表示。

print(math.frxp(2.3))#(0.575, 2)
1

(9)math.fsum[iterable]

返回浮点数之和

print(math.fsum([0.1,0.2]))#0.300000004
print(math.fsum([0.1,0.2,2]))#2.3
1
2

(10)math.gcd(a,b)

转入参数x，y为整数

返回a和b的最大公约数

注：如果只传入一个参数，则会返回其本身

print(math.gcd(4,2))#2
print(math.gcd(8,5))#1
print(math.gcd(4))#4
1
2
3

(11)math.isclose(a, b, *, rel_tol=1e-09, abs_tol=0.0)

传入参数为a,b为任意整数、浮点数

若 a 和 b 的值比较接近则返回 True，否则返回 False

abs_tol 是最小绝对容差 —— 对于接近零的比较很有用。 abs_tol 必须至少为零。

如果没有错误发生，结果将是： abs(a-b) <= max(rel_tol * max(abs(a), abs(b)), abs_tol) 。

(12)math.isfinite(x)

传入x为任意值

如果 x 既不是无穷大也不是NaN，则返回 True ，否则返回 False 。

zuidazhi = math.inf
print(math.finite(zuidazhi))#False
print(math.finite(1000000000000000000000000000000000000))#True
1
2
3

(13)math.isinf(x)

传入x为任意值

如果 x 是正无穷大或负无穷大，则返回 True ，否则返回 False

zuidazhi = math.inf
print(math.isinf(zuidazhi))#True
print(math.isinf(1000000000000000000000000000000000000))#False
1
2
3

(14)math.isnan(x)

传入x为nan,浮点数，整数

如果 x 是 NaN（不是数字），则返回 True ，否则返回 False

t = math.nan
print(math.isnan(t))#True
print(math.isnan(1))#False
1
2
3

(15)math.isqrt(x)

传入x为任意值

返回非负整数 n 的整数平方根。 这就是对 n 的实际平方根向下取整，或者相当于使得 a² ≤ n 的最大整数 a。

print(math.isqrt(2))#1
print(math.isqrt(4))#2
print(math.isqrt(7))#2
1
2
3

(16)math.lcm(*integers)

传入参数为任意个整数

返回给定的整数参数的最小公倍数。 如果所有参数均非零，则返回值将是为所有参数的整数倍的最小正整数。

注：如果参数之一为零，则返回值为 0。 不带参数的 lcm() 返回 1。

print(math.lcm(2,24,52))#312
print(math.lcm(-2,2))#2
print(math.lcm(-11,-2))#22
print(math.lcm(-2))#2
1
2
3
4

(17)math.ldexp(x,j)

传入参数x为浮点数，整数，j为整数

返回 x * (2**i) 。 这基本上是函数frexp()的反函数。

print(math.ldexp(5,2))#20
print(math.ldexp(4,6))#256
1
2

(18)math.modf(x)

传入参数x为整数浮点数

返回 x 的小数和整数部分

print(math.modf(1.2))#(0.19999999999999996, 1.0)
print(math.modf(1.6))#(0.6000000000000001, 1.0)
print(math.modf(1))#(0.0, 1.0)
1
2
3

(19)math.nextafter(x,y)

返回 x 趋向于 y 的最接近的浮点数值。

如果 x 等于 y 则返回 y。

注：

• math.nextafter(x, math.inf) 的方向朝上：趋向于正无穷。

• math.nextafter(x, -math.inf) 的方向朝下：趋向于负无穷。

• math.nextafter(x, 0.0) 趋向于零。

• math.nextafter(x, math.copysign(math.inf, x)) 趋向于零的反方向。

  print(math.nextafter(2,2.512351325))#2.0000000000000004
  print(math.nextafter(2.24,3.512351325))#2.2400000000000007
  1
  2

(20)math.prem(n,k=None)

传入参数n,k为非负正整数

返回不重复且有顺序地从 n 项中选择 k 项的方式总数。

当 k <= n 时取值为 n! / (n - k)!；当 k > n 时取值为零。

如果 k 未指定或为 None，则 k 默认值为 n 并且函数将返回 n!。

print(math.perm(3,2))#6
print(math.perm(5,2))#20
1
2

(21)math.pron(iterable, *, start=1)

传入可迭代对象

计算输入的 iterable 中所有元素的积。 积的默认 start 值为 1。

当可迭代对象为空时，返回起始值。 此函数特别针对数字值使用，并会拒绝非数字类型。

print(math.prod([1,23,312]))#7176
1

(22)math.remainder(x,y)

返回 IEEE 754 风格的 x 相对于 y 的余数。对于有限 x 和有限非零 y ，这是差异 x - n*y ，其中 n 是与商 x / y 的精确值最接近的整数。如果 x / y 恰好位于两个连续整数之间，则将最接近的 偶数 用作 n 。 余数 r = remainder(x, y) 因此总是满足 abs(r) <= 0.5 * abs(y)。

特殊情况遵循IEEE 754：特别是 remainder(x, math.inf) 对于任何有限 x 都是 x ，而 remainder(x, 0) 和 remainder(math.inf, x) 引发 ValueError 适用于任何非NaN的 x 。如果余数运算的结果为零，则该零将具有与 x 相同的符号。

(23)math.trunc(x)

传入参数浮点数x

返回去除小数部分的 x ，只留下整数部分。

print(math.trunc(5.4))#5
print(math.trunc(4.5))#4
1
2

(24)math.ulp(x)

返回浮点数 x 的最小有效比特位的值:

• 如果 x 是 NaN (非数字)，则返回 x。

• 如果 x 为负数，则返回 ulp(-x)。

• 如果 x 为正数，则返回 x。

• 如果 x 等于零，则返回 去正规化的 可表示最小正浮点数 (小于 正规化的 最小正浮点数 sys.float_info.min)。

• 如果 x 等于可表示最大正浮点数，则返回 x 的最低有效比特位的值，使得小于 x 的第一个浮点数为 x - ulp(x)。

• 在其他情况下 (x 是一个有限的正数)，则返回 x 的最低有效比特位的值，使得大于 x 的第一个浮点数为 x + ulp(x)。

  print(math.ulp(2.3))#4.440892098500626e-16
  print(math.ulp(2.5))#4.440892098500626e-16
  1
  2

3.幂函数、对数函数、三角函数、双曲函数、角度转换

（1）幂函数

math.cbrt(x)

返回x的立方

print(math.cbrt(3))#27
print(math.cbrt(2))#8
1
2

math.exp(x)

返回 e 次 x 幂，其中 e = 2.718281… 是自然对数的基数。这通常比 math.e ** x 或 pow(math.e, x) 更精确。

print(math.exp(2))#7.38905609893065
print(math.exp(2.5))#12.182493960703473
1
2

math.expm1(x)

返回 e 的 x 次幂，减1。这里 e 是自然对数的基数。对于小浮点数 x ， exp(x) - 1 中的减法可能导致 significant loss of precision； expm1()函数提供了一种将此数量计算为全精度的方法:

print(exp(1e-5) - 1)  # gives result accurate to 11 places
1.0000050000069649e-05
print(expm1(1e-5))    # result accurate to full precision
1.0000050000166668e-05
1
2
3
4

math.pow(x, y）

与内置的 ** 运算符不同， math.pow() 将其参数转换为 float 类型。使用 ** 或内置的 pow() 函数来计算精确的整数幂。

print(math.pow(2,3))#8.0
print(math.pow(4,5.4))#1782.8875536304631
1
2

（2）对数函数

math.log(x[, base])

使用一个参数，返回 x 的自然对数（底为 e ）。使用两个参数，返回给定的 base 的对数 x ，计算为 log(x)/log(base)

print(math.log(10))#2.302585092994046
print(math.log(10,3))#2.095903274289385
print(math.log(10,4))#1.6609640474436813
1
2
3

math.log1p(x)

返回 1+x 的自然对数（以 e 为底）。 以对于接近零的 x 精确的方式计算结果

print(math.log1p(10))#2.3978952727983707
print(math.log1p(11))#2.4849066497880004
1
2

math.log2(x)

返回 x 以2为底的对数。这通常比 log(x, 2) 更准确。*3.3 新版功能.*参见 int.bit_length() 返回表示二进制整数所需的位数，不包括符号和前导零

print(math.log2(2))#1.0
print(math.log2(10))#3.321928094887362
1
2

math.log10(x)

返回 x 底为10的对数。这通常比 log(x, 10) 更准确

print(math.log10(10))#1.0
print(math.log10(2))#0.3010299956639812
1
2

math.sqrt()

返回 x 的平方根。

print(math.sqrt(2))#1.4142135623730951
print(math.sqrt(4))#2.0
1
2

（3）三角函数

math.acos(x)

返回以弧度为单位的 x 的反余弦值。 结果范围在 0 到 pi 之间。

print(math.acos(1))#0.0
print(math.acos(0.5))#1.0471975511965976
1
2

math.asin(x)

返回以弧度为单位的 x 的反正弦值。 结果范围在 -pi/2 到 pi/2 之间。

print(math.asin(1))#1.5707963267948966
print(math.asin(0.5))#0.5235987755982988
1
2

math.atan(x)

返回以弧度为单位的 x 的反正切值。 结果范围在 -pi/2 到 pi/2 之间。.

print(math.atan(1))#0.7853981633974483
print(math.atan(0))#0.0
1
2

math.atan2(y, x)

以弧度为单位返回 atan(y / x) 。结果是在 -pi 和 pi 之间。从原点到点 (x, y) 的平面矢量使该角度与正X轴成正比。 atan2() 的点的两个输入的符号都是已知的，因此它可以计算角度的正确象限。 例如， atan(1) 和 atan2(1, 1) 都是 pi/4 ，但 atan2(-1, -1) 是 -3*pi/4 。

print(math.atan2(2,1))#1.1071487177940904
print(math.atan2(4,3))#0.9272952180016122
1
2

math.cos(x)

返回 x 弧度的余弦值。

print(math.sin(0))#0.0
print(math.sin(math.pi))#0.0
1
2

math.dist(p, q)

返回 p 与 q 两点之间的欧几里得距离，以一个坐标序列（或可迭代对象）的形式给出。 两个点必须具有相同的维度。大致相当于：sqrt(sum((px - qx) ** 2.0 for px, qx in zip(p, q)))

print(math.dist((3,4),(5,6)))#2.8284271247461903
print(math.dist((3,4),(3,5)))#1.0
1
2

math.hypot(*coordinates)

返回欧几里得范数，sqrt(sum(x**2 for x in coordinates))。 这是从原点到坐标给定点的向量长度。对于一个二维点 (x, y)，这等价于使用毕达哥拉斯定义 sqrt(x*x + y*y) 计算一个直角三角形的斜边.

print(math.hypot(3,4))#5.0
print(math.hypot(12,5))#13.0
1
2

math.sin(x)

返回 x 弧度的正弦值。

print(math.sin(0))#0.0
print(math.sin(math.pi))#0.0
1
2

math.tan(x)

返回 x 弧度的正切值。

print(math.tan(0))#0.0
print(math.tan(math.pi/4))#0.9999999
1
2

（4）双曲函数

math.acosh(x)

返回 x 的反双曲余弦值。

print(math.acosh(1))#0.0

print(math.acosh(2))#1.3169578969248166
1
2
3

math.asinh(x)

返回 x 的反双曲正弦值。

print(math.asinh(1))#0.881373587019543
print(math.asinh(0.5))#0.4812118250596034
1
2

math.atanh(x)

返回 x 的反双曲正切值。

print(math.atanh(0.3))#0.30951960420311175
print(math.atanh(0.5))#0.5493061443340549

1
2
3

math.cosh(x)

返回 x 的双曲余弦值。

print(math.cosh(math.pi))#11.591953275521519
1

math.sinh(x)

返回 x 的双曲正弦值。

print(math.sinh(math.pi))#11.548739357257746
1

math.tanh(x)

返回 x 的双曲正切值。

print(math.tanh(math.pi))#0.99627207622075
1

（5）角度转换

math.degrees(x)

将角度 x 从弧度转换为度数。

print(math.sin(math.degrees(math.pi/2)))
print(math.sin(math.degrees(math.pi)))
1
2

math.radians(x)

将角度 x 从度数转换为弧度。

print(math.sin(math.radians(45)))#0.7071067811865475
print(math.sin(math.radians(90)))#1.0
1
2