Python3标准库：math数学函数

Python3标准库：math数学函数
1. math数学函数
1.1 特殊常量
很多数学运算依赖于⼀些特殊的常量。

math包含有π(pi)、e、nan(不是⼀个数)和infinity(⽆穷⼤)的值。

import math
print(' π: {:.30f}'.format(math.pi))
print(' e: {:.30f}'.format(math.e))
print('nan: {:.30f}'.format(math.nan))
print('inf: {:.30f}'.format(math.inf))
π和e的精度仅受平台的浮点数C库限制。

1.2 测试异常值
浮点数计算可能导致两种类型的异常值。

第⼀种是inf(⽆穷⼤)，当⽤double存储⼀个浮点数，⽽该值会从⼀个具体很⼤绝对值的值上溢出时，就会出现这个异常值。

import math
print('{:^3} {:6} {:6} {:6}'.format(
'e', 'x', 'x**2', 'isinf'))
print('{:-^3} {:-^6} {:-^6} {:-^6}'.format(
'', '', '', ''))
for e in range(0, 201, 20):
x = 10.0 ** e
y = x * x
print('{:3d} {:<6g} {:<6g} {!s:6}'.format(
e, x, y, math.isinf(y),
))
当这个例⼦中的指数变得⾜够⼤时，x的平⽅⽆法再存放⼀个double中，这个值就会被记录为⽆穷⼤。

不过，并不是所有浮点数溢出都会导致inf值。

具体地，⽤浮点值计算⼀个指数时，会产⽣OverflowError⽽不是保留inf结果。

x = 10.0 ** 200
print('x =', x)
print('x*x =', x * x)
print('x**2 =', end='')
try:
print(x ** 2)
except OverflowError as err:
print(err)
这种差异是由C和Python所⽤库中的实现差异造成的。

使⽤⽆穷⼤值的除法运算未定义。

将⼀个数除以⽆穷⼤值的结果是nan(不是⼀个数)。

import math
x = (10.0 ** 200) * (10.0 ** 200)
y = x / x
print('x =', x)
print('isnan(x) =', math.isnan(x))
print('y = x / x =', x / x)
print('y == nan =', y == float('nan'))
print('isnan(y) =', math.isnan(y))
nan不等于任何值，甚⾄不等于其⾃⾝，所以要想检查nan，需要使⽤isnan()。

可以使⽤isfinite()检查其是普通的数还是特殊值inf或nan。

import math
for f in [0.0, 1.0, math.pi, math.e, math.inf, math.nan]:
print('{:5.2f} {!s}'.format(f, math.isfinite(f)))
如果是特殊值inf或nan，则isfinite()返回false，否则返回true。

1.3 ⽐较
涉及浮点值的⽐较容易出错，每⼀步计算都可能由于数值表⽰⽽引⼊误差，isclose()函数使⽤⼀种稳定的算法来尽可能减少这些误差，同时完成相对和绝对⽐较。

所⽤的公式等价于：
abs(a-b) <= max(rel_tol * max(abs(a), abs(b)), abs_tol)
默认地，isclose()会完成相对⽐较，容差被设置为le-09，这表⽰两个值之差必须⼩于或等于le乘以a和b中较⼤的绝对值。

向isclose()传⼊关键字参数rel_tol可以改变这个容差。

在这个例⼦中，值之间的差距必须在10%以内。

import math
INPUTS = [
(1000, 900, 0.1),
(100, 90, 0.1),
(10, 9, 0.1),
(1, 0.9, 0.1),
(0.1, 0.09, 0.1),
]
print('{:^8} {:^8} {:^8} {:^8} {:^8} {:^8}'.format(
'a', 'b', 'rel_tol', 'abs(a-b)', 'tolerance', 'close')
)
print('{:-^8} {:-^8} {:-^8} {:-^8} {:-^8} {:-^8}'.format(
'-', '-', '-', '-', '-', '-'),
)
fmt = '{:8.2f} {:8.2f} {:8.2f} {:8.2f} {:8.2f} {!s:>8}'
for a, b, rel_tol in INPUTS:
close = math.isclose(a, b, rel_tol=rel_tol)
tolerance = rel_tol * max(abs(a), abs(b))
abs_diff = abs(a - b)
print(fmt.format(a, b, rel_tol, abs_diff, tolerance, close))
0.1和0.09之间的⽐较失败，因为误差表⽰0.1。

要使⽤⼀个固定或“绝对”容差，可以传⼊abs_tol⽽不是rel_tol。

import math
INPUTS = [
(1.0, 1.0 + 1e-07, 1e-08),
(1.0, 1.0 + 1e-08, 1e-08),
(1.0, 1.0 + 1e-09, 1e-08),
]
print('{:^8} {:^11} {:^8} {:^10} {:^8}'.format(
'a', 'b', 'abs_tol', 'abs(a-b)', 'close')
)
print('{:-^8} {:-^11} {:-^8} {:-^10} {:-^8}'.format(
'-', '-', '-', '-', '-'),
)
for a, b, abs_tol in INPUTS:
close = math.isclose(a, b, abs_tol=abs_tol)
abs_diff = abs(a - b)
print('{:8.2f} {:11} {:8} {:0.9f} {!s:>8}'.format(
a, b, abs_tol, abs_diff, close))
对于绝对容差，输⼊值之差必须⼩于给定的容差。

nan和inf是特殊情况。

import math
print('nan, nan:', math.isclose(math.nan, math.nan))
print('nan, 1.0:', math.isclose(math.nan, 1.0))
print('inf, inf:', math.isclose(math.inf, math.inf))
print('inf, 1.0:', math.isclose(math.inf, 1.0))
nan不接近任何值，包括它⾃⾝。

inf只接近它⾃⾝。

1.4 将浮点值转换为整数
math模块中有3个函数⽤于将浮点值转换为整数。

这3个函数分别采⽤不同的⽅法，并适⽤于不同的场合。

最简单的是trunc()，其会截断⼩数点后的数字，只留下构成这个值整数部分的有效数字。

floor()将其输⼊转换为不⼤于它的最⼤整数，ceil() (上限)会⽣成按顺序排在这个输⼊值之后的最⼩整数。

import math
HEADINGS = ('i', 'int', 'trunk', 'floor', 'ceil')
print('{:^5} {:^5} {:^5} {:^5} {:^5}'.format(*HEADINGS))
print('{:-^5} {:-^5} {:-^5} {:-^5} {:-^5}'.format(
'', '', '', '', '',
))
fmt = '{:5.1f} {:5.1f} {:5.1f} {:5.1f} {:5.1f}'
TEST_VALUES = [
-1.5,
-0.8,
-0.5,
-0.2,
0,
0.2,
0.5,
0.8,
1,
]
for i in TEST_VALUES:
print(fmt.format(
i,
int(i),
math.trunc(i),
math.floor(i),
math.ceil(i),
))
trunc()等价于直接转换为int。

1.5 浮点值的其他表⽰
modf()取⼀个浮点数，并返回⼀个元组，其中包含这个输⼊值的⼩数和整数部分。

import math
for i in range(6):
print('{}/2 = {}'.format(i, math.modf(i / 2.0)))
返回值中的两个数字均为浮点数。

frexp()返回⼀个浮点数的尾数和指数，可以⽤这个函数创建值的⼀种更可移植的表⽰。

import math
print('{:^7} {:^7} {:^7}'.format('x', 'm', 'e'))
print('{:-^7} {:-^7} {:-^7}'.format('', '', ''))
for x in [0.1, 0.5, 4.0]:
m, e = math.frexp(x)
print('{:7.2f} {:7.2f} {:7d}'.format(x, m, e))
frexp()使⽤公式x = m * 2**e，并返回值m和e。

ldexp()与frexp()正好相反。

import math
print('{:^7} {:^7} {:^7}'.format('m', 'e', 'x'))
print('{:-^7} {:-^7} {:-^7}'.format('', '', ''))
INPUTS = [
(0.8, -3),
(0.5, 0),
(0.5, 3),
]
for m, e in INPUTS:
x = math.ldexp(m, e)
print('{:7.2f} {:7d} {:7.2f}'.format(m, e, x))
ldexp()使⽤与frexp()相同的公式，取尾数和指数值作为参数，并返回⼀个浮点数。

1.6 正号和负号
⼀个数的绝对值就是不带正负号的本值。

使⽤fabs()可以计算⼀个浮点数的绝对值。

import math
print(math.fabs(-1.1))
print(math.fabs(-0.0))
print(math.fabs(0.0))
print(math.fabs(1.1))
在实际中，float的绝对值表⽰为⼀个正值。

要确定⼀个值的符号，以便为⼀组值指定相同的符号或者⽐较两个值，可以使⽤copysign()来设置正确值的符号。

import math
HEADINGS = ('f', 's', '< 0', '> 0', '= 0')
print('{:^5} {:^5} {:^5} {:^5} {:^5}'.format(*HEADINGS))
print('{:-^5} {:-^5} {:-^5} {:-^5} {:-^5}'.format(
'', '', '', '', '',
))
VALUES = [
-1.0,
0.0,
1.0,
float('-inf'),
float('inf'),
float('-nan'),
float('nan'),
]
for f in VALUES:
s = int(math.copysign(1, f))
print('{:5.1f} {:5d} {!s:5} {!s:5} {!s:5}'.format(
f, s, f < 0, f > 0, f == 0,
))
还需要另⼀个类似copysign()的函数，因为不能将nan和-nan与其他值直接⽐较。

1.7 常⽤计算
在⼆进制浮点数内存中表⽰精确度很有难度。

有些值⽆法准确地表⽰，⽽且如果通过反复计算来处理⼀个值，那么计算越频繁就越容易引⼈表⽰误差。

math包含⼀个函数来计算⼀系列浮点数的和，它使⽤⼀种⾼效的算法来尽量减少这种误差。

import math
values = [0.1] * 10
print('Input values:', values)
print('sum() : {:.20f}'.format(sum(values)))
s = 0.0
for i in values:
s += i
print('for-loop : {:.20f}'.format(s))
print('math.fsum() : {:.20f}'.format(math.fsum(values)))
给定⼀个包含10个值的序列，每个值都等于0.1，这个序列总和的期望值为1.0。

不过，由于0.1不能精确地表⽰为⼀个浮点数，所以会在总和中引⼊误差，除⾮⽤fsum()来计算。

factorial()常⽤于计算⼀系列对象的排列和组合数。

⼀个正整数n的阶乘(表⽰为n!)被递归的定义为(n-1)!*n，并在0!==1停⽌递归。

import math
for i in [0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.1]:
try:
print('{:2.0f} {:6.0f}'.format(i, math.factorial(i)))
except ValueError as err:
print('Error computing factorial({}): {}'.format(i, err))
factorial()只能处理整数，不过它确实也接受float参数，只要这个参数可以转换为⼀个整数⽽不丢值。

gamma()类似于factorial()，不过它可以处理实数，⽽且值会下移⼀个数(gamma等于(n - 1)!)。

import math
for i in [0, 1.1, 2.2, 3.3, 4.4, 5.5, 6.6]:
try:
print('{:2.1f} {:6.2f}'.format(i, math.gamma(i)))
except ValueError as err:
print('Error computing gamma({}): {}'.format(i, err))
由于0会导致开始值为负，所以这是不允许的。

lgamma()会返回对输⼊值求gamma所得结果的绝对值的⾃然对数。

import math
for i in [0, 1.1, 2.2, 3.3, 4.4, 5.5, 6.6]:
try:
print('{:2.1f} {:.20f} {:.20f}'.format(
i,
math.lgamma(i),
math.log(math.gamma(i)),
))
except ValueError as err:
print('Error computing lgamma({}): {}'.format(i, err))
使⽤lgamma()会⽐使⽤gamma()结果单独计算对数更精确。

求模操作符(%)会计算⼀个除法表达式的余数(例如，5 % 2 = 1)。

Python语⾔内置的这个操作符可以很好地处理整数，但是与很多其他浮点数运算类似，中间计算可能带来表⽰问题，从⽽进⼀步造成数据丢失。

fmod()可以为浮点值提供⼀个更精确的实现。

import math
print('{:^4} {:^4} {:^5} {:^5}'.format(
'x', 'y', '%', 'fmod'))
print('{:-^4} {:-^4} {:-^5} {:-^5}'.format(
'-', '-', '-', '-'))
INPUTS = [
(5, 2),
(5, -2),
(-5, 2),
]
for x, y in INPUTS:
print('{:4.1f} {:4.1f} {:5.2f} {:5.2f}'.format(
x,
y,
x % y,
math.fmod(x, y),
))
还有⼀点可能经常产⽣混淆，即fmod()计算模所使⽤的算法与%使⽤的算法也有所不同，所以结果的符号不同。

可以使⽤gcd()找出两个整数公约数中最⼤的整数——也就是最⼤公约数。

import math
print(math.gcd(10, 8))
print(math.gcd(10, 0))
print(math.gcd(50, 225))
print(math.gcd(11, 9))
print(math.gcd(0, 0))
如果两个值都为0，则结果为0。

1.8 指数和对数
指数⽣长曲线在经济学、物理学和其他科学中经常出现。

Python有⼀个内置的幂运算符(“**”)，不过，如果需要将⼀个可调⽤函数作为另⼀个函数的参数，那么可能需要⽤到pow()。

import math
INPUTS = [
# Typical uses
(2, 3),
(2.1, 3.2),
# Always 1
(1.0, 5),
(2.0, 0),
# Not-a-number
(2, float('nan')),
# Roots
(9.0, 0.5),
(27.0, 1.0 / 3),
]
for x, y in INPUTS:
print('{:5.1f} ** {:5.3f} = {:6.3f}'.format(
x, y, math.pow(x, y)))
1的任何次幂总返回1.0，同样，任何值的指数为0.0时也总是返回1.0.对于nan值(不是⼀个数)，⼤多数运算都返回nan。

如果指数⼩于
1，pow()会计算⼀个根。

由于平⽅根(指数为1/2)被使⽤的⾮常频繁，所以有⼀个单独的函数来计算平⽅根。

import math
print(math.sqrt(9.0))
print(math.sqrt(3))
try:
print(math.sqrt(-1))
except ValueError as err:
print('Cannot compute sqrt(-1):', err)
计算负数的平⽅根需要⽤到复数，这不在math的处理范围内。

试图计算⼀个负值的平⽅根时，会导致⼀个ValueError。

对数函数查找满⾜条件x=b**y的y。

默认log()计算⾃然对数(底数为e)。

如果提供了第⼆个参数，则使⽤这个参数值作为底数。

import math
print(math.log(8))
print(math.log(8, 2))
print(math.log(0.5, 2))
x⼩于1时，求对数会产⽣负数结果。

log()有三个变形。

在给定浮点数表⽰和取整误差的情况下，由log(x,b)⽣成的计算值只有有限的精度(特别是对于某些底数)。

log10()完成log(x,10)计算，但是会使⽤⼀种⽐log()更精确的算法。

import math
print('{:2} {:^12} {:^10} {:^20} {:8}'.format(
'i', 'x', 'accurate', 'inaccurate', 'mismatch',
))
print('{:-^2} {:-^12} {:-^10} {:-^20} {:-^8}'.format(
'', '', '', '', '',
))
for i in range(0, 10):
x = math.pow(10, i)
accurate = math.log10(x)
inaccurate = math.log(x, 10)
match = ''if int(inaccurate) == i else'*'
print('{:2d} {:12.1f} {:10.8f} {:20.18f} {:^5}'.format(
i, x, accurate, inaccurate, match,
))
输出中末尾有*的⾏突出强调了不精确的值。

类似于log10()，log2()会完成等价于math.log(x,2)的计算。

import math
print('{:>2} {:^5} {:^5}'.format(
'i', 'x', 'log2',
))
print('{:-^2} {:-^5} {:-^5}'.format(
'', '', '',
))
for i in range(0, 10):
x = math.pow(2, i)
result = math.log2(x)
print('{:2d} {:5.1f} {:5.1f}'.format(
i, x, result,
))
取决于底层平台，这个内置的特殊⽤途函数能提供更好的性能和精度，因为它利⽤了针对底数2的特殊⽤途算法，⽽在更⼀般⽤途的函数中没有使⽤这些算法。

log1p()会计算Newton-Mercator序列(1+x的⾃然对数)。

import math
x = 0.0000000000000000000000001
print('x :', x)
print('1 + x :', 1 + x)
print('log(1+x):', math.log(1 + x))
print('log1p(x):', math.log1p(x))
对于⾮常接近于0的x，log1p()会更为精确，因为它使⽤的算法可以补偿由初识加法带来的取整误差。

exp()会计算指数函数(e**x)。

import math
x = 2
fmt = '{:.20f}'
print(fmt.format(math.e ** 2))
print(fmt.format(math.pow(math.e, 2)))
print(fmt.format(math.exp(2)))
类似于其他特殊函数，与等价的通⽤函数math.pow(math.e,x)相⽐，exp()使⽤的算法可以⽣成更精确的结果。

expm1()是log1p()的逆运算，会计算e**x-1。

import math
x = 0.0000000000000000000000001
print(x)
print(math.exp(x) - 1)
print(math.expm1(x))
类似于log1p()，x值很⼩时，如果单独完成减法，则可能会损失精度。

1.9 ⾓
尽管我们每天讨论⾓时更常⽤的是度，但弧度才是科学和数学领域中度量⾓度的标准单位。

弧度是在圆⼼相交的两条线所构成的⾓，其终点落在圆的圆周上，终点之间相距⼀个弧度。

圆周长计算为2πr，所以弧度与π(这是三⾓函数计算中经常出现的⼀个值)之间存在⼀个关系。

这个关系使得三⾓学和微积分中都使⽤了弧度，因为利⽤弧度可以得到更紧凑的公式。

要把度转换为弧度，可以使⽤redians()。

import math
print('{:^7} {:^7} {:^7}'.format(
'Degrees', 'Radians', 'Expected'))
print('{:-^7} {:-^7} {:-^7}'.format(
'', '', ''))
INPUTS = [
(0, 0),
(30, math.pi / 6),
(45, math.pi / 4),
(60, math.pi / 3),
(90, math.pi / 2),
(180, math.pi),
(270, 3 / 2.0 * math.pi),
(360, 2 * math.pi),
]
for deg, expected in INPUTS:
print('{:7d} {:7.2f} {:7.2f}'.format(
deg,
math.radians(deg),
expected,
))
转换公式为rad = deg * π / 180。

要从弧度转换为度，可以使⽤degrees()。

import math
INPUTS = [
(0, 0),
(math.pi / 6, 30),
(math.pi / 4, 45),
(math.pi / 3, 60),
(math.pi / 2, 90),
(math.pi, 180),
(3 * math.pi / 2, 270),
(2 * math.pi, 360),
]
print('{:^8} {:^8} {:^8}'.format(
'Radians', 'Degrees', 'Expected'))
print('{:-^8} {:-^8} {:-^8}'.format('', '', ''))
for rad, expected in INPUTS:
print('{:8.2f} {:8.2f} {:8.2f}'.format(
rad,
math.degrees(rad),
expected,
))
具体转换公式为deg = rad * 180 / π。

1.10 三⾓函数
三⾓函数将三⾓形中的⾓与其边长相关联。

在有周期性质的公式中经常出现三⾓函数，如谐波或圆周运动；在处理⾓时也会经常⽤到三⾓函数。

标准库中所有三⾓函数的⾓参数都被表⽰为弧度。

给定⼀个直⾓三⾓形中的⾓，其正弦是对边长度与斜边长度之⽐(sin A = 对边/斜边)。

余弦是邻边长度与斜边长度之⽐(cos A = 邻边/斜边)。

正切是对边与邻边之⽐(tan A = 对边/邻边)。

import math
print('{:^7} {:^7} {:^7} {:^7} {:^7}'.format(
'Degrees', 'Radians', 'Sine', 'Cosine', 'Tangent'))
print('{:-^7} {:-^7} {:-^7} {:-^7} {:-^7}'.format(
'-', '-', '-', '-', '-'))
fmt = '{:7.2f} {:7.2f} {:7.2f} {:7.2f} {:7.2f}'
for deg in range(0, 361, 30):
rad = math.radians(deg)
if deg in (90, 270):
t = float('inf')
else:
t = math.tan(rad)
print(fmt.format(deg, rad, math.sin(rad), math.cos(rad), t))
正切也可以被定义为⾓的正弦值与其余弦值之⽐，因为弧度π/2和3π/2的余弦是0，所以相应的正切值为⽆穷⼤。

给定⼀个点(x,y)，点[(0,0),(x,0),(x,y)]构成的三⾓形中斜边长度为(x**2+y**2)**1/2，可以⽤hypot()来计算。

import math
print('{:^7} {:^7} {:^10}'.format('X', 'Y', 'Hypotenuse'))
print('{:-^7} {:-^7} {:-^10}'.format('', '', ''))
POINTS = [
# simple points
(1, 1),
(-1, -1),
(math.sqrt(2), math.sqrt(2)),
(3, 4), # 3-4-5 triangle
# on the circle
(math.sqrt(2) / 2, math.sqrt(2) / 2), # pi/4 rads
(0.5, math.sqrt(3) / 2), # pi/3 rads
]
for x, y in POINTS:
h = math.hypot(x, y)
print('{:7.2f} {:7.2f} {:7.2f}'.format(x, y, h))
对于圆上的点，其斜边总是等于1。

还可以⽤这个函数查看两个点之间的距离。

import math
print('{:^8} {:^8} {:^8} {:^8} {:^8}'.format(
'X1', 'Y1', 'X2', 'Y2', 'Distance',
))
print('{:-^8} {:-^8} {:-^8} {:-^8} {:-^8}'.format(
'', '', '', '', '',
))
POINTS = [
((5, 5), (6, 6)),
((-6, -6), (-5, -5)),
((0, 0), (3, 4)), # 3-4-5 triangle
((-1, -1), (2, 3)), # 3-4-5 triangle
]
for (x1, y1), (x2, y2) in POINTS:
x = x1 - x2
y = y1 - y2
h = math.hypot(x, y)
print('{:8.2f} {:8.2f} {:8.2f} {:8.2f} {:8.2f}'.format(
x1, y1, x2, y2, h,
))
使⽤x值之差和y值之差将⼀个端点移⾄原点，然后将结果传⼊hypot()。

math还定义了反三⾓函数。

import math
for r in [0, 0.5, 1]:
print('arcsine({:.1f}) = {:5.2f}'.format(r, math.asin(r)))
print('arccosine({:.1f}) = {:5.2f}'.format(r, math.acos(r)))
print('arctangent({:.1f}) = {:5.2f}'.format(r, math.atan(r)))
print()
1.57⼤约对于π/2，或90度，这个⾓的正弦为1，余弦为0。

1.11 双曲函数
双曲函数经常出现在线性微分⽅程中，处理电磁场、流体⼒学、狭义相对论和其他⾼级物理和数学问题时常会⽤到。

import math
print('{:^6} {:^6} {:^6} {:^6}'.format(
'X', 'sinh', 'cosh', 'tanh',
))
print('{:-^6} {:-^6} {:-^6} {:-^6}'.format('', '', '', ''))
fmt = '{:6.4f} {:6.4f} {:6.4f} {:6.4f}'
for i in range(0, 11, 2):
x = i / 10.0
print(fmt.format(
x,
math.sinh(x),
math.cosh(x),
math.tanh(x),
))
余弦函数和正弦函数构成⼀个圆，⽽双曲余弦函数和双曲正弦函数构成半个双曲线。

另外还提供了反双曲函数acosh()、asinh()和atanh()。

1.12 特殊函数
统计学中经常⽤到⾼斯误差函数(Gauss error function)。

import math
print('{:^5} {:7}'.format('x', 'erf(x)'))
print('{:-^5} {:-^7}'.format('', ''))
for x in [-3, -2, -1, -0.5, -0.25, 0, 0.25, 0.5, 1, 2, 3]:
print('{:5.2f} {:7.4f}'.format(x, math.erf(x)))
对于误差函数，erf(-x) == -erf(x)。

补余误差函数erfc()⽣成等价于1 - erf(x)的值。

import math
print('{:^5} {:7}'.format('x', 'erfc(x)'))
print('{:-^5} {:-^7}'.format('', ''))
for x in [-3, -2, -1, -0.5, -0.25, 0, 0.25, 0.5, 1, 2, 3]:
print('{:5.2f} {:7.4f}'.format(x, math.erfc(x)))
如果x值很⼩，那么在从1做减法时erfc()实现便可以避免可能的精度误差。