Python 标准库之 Math 数学函数

Python 标准库之 Math 数学函数

---

导入模块‍♂️

import math

math 为标准库下的模块，直接导入即可

---

Math 常量

常量部分源码

math.pi

返回 圆周率 π = 3.141592…，精确到 小数点后 15 位

pi = math.pi

math.e

返回数学常数 e = 2.718281…，精确到 小数点后 15 位

e = math.e

math.tau

返回数学常数 τ = 6.283185…，精确到 小数点后 15 位。
Tau 是一个圆周常数，等于 2π，圆的周长与半径之比。

tau = math.tau

math.inf

表示 浮点正无穷大 ，要表示负无穷大，得使用 -math.inf ，相当于 float(‘inf’)、float("-inf") 的输出

• 正无穷大：inf
• 负无穷大：-inf

Positive_infinity = math.inf
Negative_infinity = -math.inf

math.nan

表示 NaN : Not a Number（非数字） 代表不是一个数字，浮点数类型，相当于 float(‘nan’) 的输出，通常只用于表示缺少某些数据

---

Math 表示函数

math.ceil(x) 常用

返回 x 的上限值

x 为浮点数时则 向上取整，为整数时直接返回，不做任何更改

num1 = 5.668
num2 = 5
print(math.ceil(num1))   # 结果为 6
print(math.ceil(num2))   # 结果为 5

math.floor(x) 常用

返回 x 的向下取整

x 为浮点数时则 向下取整，为整数时直接返回，不做任何更改

num1 = 5.668
num2 = 4
print(math.floor(num1))   # 结果为 5
print(math.floor(num2))   # 结果为 4

math.comb(n, k)

返回 不重复且无顺序地 从 n 项中选择 k 项的方式总数
当 k <= n 时取值为『n! / (k! * (n - k)!)』，当 k > n 时取值为零。也称为二项式系数，因为它等价于表达式 (1 + x) ** n 的多项式展开中第 k 项的系数。

图解

print(math.comb(4, 2))     # 结果为 6

如果任一参数不为整数则会引发 TypeError，如果任一参数为负数则会引发 ValueError。

math.copysign(x, y)

copysign 从字面上理解，中文释义的为 “复制符号”

返回一个 基于** x 的绝对值** 和 y 的符号 的 浮点数，就是先获取 x 绝对值，再看 y 是什么符号，将 y 的符号给 x 的绝对值，x 可以是 整数 或则 浮点数，但最后返回的值为浮点数类型。
在支持 带符号 零(-0) 的平台上，copysign(1.0, -0.0) 返回 -1.0

print(math.copysign(6.6, -2))    # 结果为 -6.6
print(math.copysign(6.6, 2))     # 结果为 6.6
print(math.copysign(6.6, -2.6))  # 结果为 -6.6
print(math.copysign(6.6, 2.6))   # 结果为 6.6
print(math.copysign(5, -2.6))    # 结果为 -5.0
print(math.copysign(5, 2))       # 结果为 5.0

math.fabs(x) 绝对值

返回 x 的绝对值，x 可以是 整数 或者 浮点数，返回的值为浮点数类型

print(math.fabs(-6))    # 结果为 6.0

math.factorial(x) 阶乘

以 一个整数 返回 x 的阶乘，如果 x 不是整数 或为 负数 时则将引发 ValueError

print(math.factorial(4))         # 4的阶乘为 24
print(math.factorial(5))         # 5的阶乘为 120

math.fmod(x, y) 取模

取模，返回除法的余数，math.fmod(x, y) 与运算符 x % y 公式相同『 x - (x / y)*x 』，但区别在 (x / y) 上的取值方式不同，x % y 将 ( x / y) 的值向下取整，而 math.fmod(x, y) 将 (x / y) 的值向0取整

图解

print(3 % 2)             # 结果为 1
print(math.fmod(3, 2))   # 结果为 1.0
print(-3 % 2)            # 结果为 1
print(math.fmod(-3, 2))  # 结果为 -1.0

math.fmod 返回的是浮点数类型

math.frexp(x)

以 (m, e) 对的形式返回 x 的 尾数 和 指数，其算式为 『 x == m * 2**e 』 ，本质是 以 2为基数 的科学计数法， m 是一个浮点数， e 是一个整数
如果 x 为零，则返回 (0.0, 0) ，否则返回 0.5 <= abs(m) < 1

print(math.frexp(300))      # 结果为 (0.5859375, 9)
print(math.frexp(-300))     # 结果为 (-0.5859375, 9)
print(0.5859375 * 2 ** 9)   # 0.5859375为尾数，2为基数，9为指数

math.fsum(iterable)

iterable 为一个可迭代对象，如：列表、元组、集合，将数组内的值进行求和计算，此方法功能与 内置函数sum() 相同，但比 sum() 能获取计算精确浮点值，返回的求和值为 浮点数类型。

print(sum([0.1] * 10))        # 结果为 0.9999999999999999
print(math.fsum([0.1] * 10))  # 结果为 1.0
print(math.fsum([6, 60]))     # 结果为 66.0

math.gcd(a, b) 最大公约数

返回 a 和 b 的 最大公约数，a 和 b 只能是整数，gcd(0, 0) 返回 0。

print(math.gcd(18, 66))     # 结果为 6
print(math.gcd(6, 7))       # 结果为 1
print(math.gcd(0, 6))       # 结果为 6
print(math.gcd(0, 0))       # 结果为 0

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

若 a 和 b 的值 比较接近则返回 True，否则返回 False，根据给定的 绝对 和 相对 容差确定两个值是接近。

• rel_tol 是相对容差 ，它是 a 和 b 之间允许的最大差值，相对于 a 或 b 的较大绝对值。例如，要设置5％的容差，请传递 rel_tol=0.05， rel_tol 必须大于零，默认容差为 1e-09（科学计数法，即为 1 乘 10的 -9 次方）。
• abs_tol 是最小绝对容差，对于接近零的比较很有用。 abs_tol 必须至少为零。

判断是否接近的公式为： abs(a-b) <= max(rel_tol * max(abs(a), abs(b)), abs_tol)

abs() 函数返回数字的绝对值。
max() 方法返回给定参数的最大值，参数可以为序列。

图解

print(math.isclose(50, 52.6, rel_tol=0.05))    # 结果为 True
print(math.isclose(50, 52.7, rel_tol=0.05))    # 结果为 False

具体来说， NaN 不被认为接近任何其他值，包括 NaN，inf 和 -inf 只被认为接近自己

print(math.isclose(math.nan, math.nan))     # 结果为 False
print(math.isclose(math.inf, math.inf))     # 结果为 True
print(math.isclose(math.inf, -math.inf))    # 结果为 False

math.isinf(x)

判断 x 是否为 正或负无穷大，是则返回 True ，否则返回 False

• 正无穷大：inf
• 负无穷大：-inf

print(math.isinf(float("inf")))  # 结果为 True
print(math.isinf(math.inf))      # 结果为 True
print(math.isinf(-math.inf))     # 结果为 True
print(math.isinf(66))            # 结果为 False

math.isnan(x)

判断 x 是否为 NaN，是则返回 True ，否则返回 False
NaN : Not a Number（非数字） 代表不是一个数字，浮点数类型

print(math.isnan(float("nan")))		# 结果为 True
print(math.isnan(math.nan))			# 结果为 True
print(math.isnan(6))				# 结果为 False

math.isfinite(x)

判断 x 是否为有限的，如果 x 既 不是无穷大 也 不是NaN，则返回 True ，否则返回 False

print(math.isfinite(0.0))           # 结果为 True
print(math.isfinite(10 ** 100))     # 结果为 True
print(math.isfinite(float("inf")))  # 结果为 False
print(math.isfinite(math.inf))      # 结果为 False
print(math.isfinite(math.nan))      # 结果为 False

math.isqrt(n) 平方根

返回 非负整数 n 的 整数平方根，对 n 的实际平方根向下取整

print(math.isqrt(9))            # 结果为 3
print(math.isqrt(6))            # 结果为 2
print(math.isqrt(3))            # 结果为 1
print(1 + math.isqrt(3 - 1))    # 先上取整写法

如果 n 为负数，会抛出ValueError异常

math.ldexp(x, i)

返回 x * (2 ** i) 的 浮点数值 ， 这基本上是函数 frexp() 的反函数

x = 66                          
m, i = math.frexp(x)            # m为尾数，i为指数
print(math.ldexp(m, i) == x)	# 结果为 True

math.modf(x)

返回 x 的 小数、整数 部分的数组，相当于对小数点前后进行了拆分，返回的值都 带有 x的符号，且都是浮点数类型

x = math.modf(5.6)
print(x)                        # 小数部分存在精确不足的问题
print(round(x[0], 1), x[-1])    # 可以使用round() 解决

(0.5999999999999996, 5.0)
0.6 5.0

math.perm(n, k=None)

返回不重复且有顺序地从 n 项中选择 k 项的方式总数，此方法类似于 comb()，但内部算式不同
当 k <= n 时取值为 『n! / (n - k)! 』；当 k > n 时取值为零。

图解

print(math.comb(4, 2))  # 结果为 6
print(math.perm(4, 2))  # 结果为 12

如果 k 未指定或为 None，则 k 默认值为 n 并且函数将返回 n!（n 的阶乘）

print(math.perm(4, 4))  
print(math.perm(4))

24
24

如果任一参数不为整数则会引发 TypeError。 如果任一参数为负数则会引发 ValueError。

math.prod(iterable, start=1)

计算输入的 iterable 中所有元素的 积

• iterable：为一个可迭代对象，如：列表、元组、集合
• start：相当于 求得 iterable 中所有元素的积 再乘于 start，默认值为 1

类似于 内置函数 sum(iterable, start=0)，将 iterable 中所有元素求和，再加上 start

print(math.prod([1, 2, 3, 4, 5, 6]))               # 结果为 720
print(math.prod([1, 2, 3, 4, 5, 6], start=0.5))    # 结果为 360.0

当可迭代对象为空时，返回起始值

print(math.prod([]))    # 结果为 1

math.remainder(x, y)

返回 x 相对于 y 的余数，对于有限 x 和有限非零 y ，计算公式为： x - n * y ，其中 n 为 x / y 的精确值最接近的整数 (应该是四舍五入)

print(math.remainder(3, 2))
print(math.remainder(6, 4))
print(math.remainder(6, 5))

-1.0
-2.0
1.0

remainder(x, math.inf) 对于任何有限 x 都是直接返回 x

print(math.remainder(6, math.inf))     # 结果为 6.0

remainder(x, 0) 和 remainder(math.inf, x) 引发 ValueError

math.trunc(x)

截取 x 的整数部分并返回

print(math.trunc(6.66666666666666666))  # 结果为6
print(math.trunc(623e-2))               # 科学计数法，实则6.23
print(math.trunc(6.0))                  # 结果为6
print(math.trunc(6))                    # 结果为6

---

Math 幂与对数

math.exp(x)

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

math.expm1(x)

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

math.log(x[, base])

使用一个参数，返回 x 的自然对数（底为 e ）。

使用两个参数，返回给定的 base 的对数 x ，计算为 log(x)/log(base) 。

math.log1p(x)

返回 1+x (base e) 的自然对数。以对于接近零的 x 精确的方式计算结果。

math.log2(x)

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

math.log10(x)

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

math.pow(x, y)

将返回 x 的 y 次幂。特殊情况尽可能遵循C99标准的附录’F’。特别是， pow(1.0, x) 和 pow(x, 0.0) 总是返回 1.0 ，即使 x 是零或NaN。 如果 x 和 y 都是有限的， x 是负数， y 不是整数那么 pow(x, y) 是未定义的，并且引发 ValueError 。

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

math.sqrt(x)

返回 x 的平方根。

---

Math 三角函数

math.acos(x)

以弧度为单位返回 x 的反余弦值。

math.asin(x)

以弧度为单位返回 x 的反正弦值。

math.atan(x)

以弧度为单位返回 x 的反正切值。

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 。

math.cos(x)

返回 x 弧度的余弦值。

math.dist(p, q)

返回 p 与 q 两点之间的欧几里得距离，以一个坐标序列（或可迭代对象）的形式给出。 两个点必须具有相同的维度。

相关博客

Python 计算平方根