[python标准库]math——数学函数 作用：提供函数完成特殊的数学运算。 Python 版本：1.4 及以后版本 math 模块实现了正常情况下内置平台 C 库中才有的很多 IEEE 函数，可以使用浮点值完成复杂的数学运算，包括对数和三角函数运算。 特殊常量 很多数学运算依赖于一些特殊的常量。math 包含有 π（pi）和 e 的值。
import math
print 'π: %.30f' % math.pi
print 'e: %.30f' % math.e
这两个值的精度仅接受平台的浮点数 C 库限制。 测试异常值 浮点数计算可能导致两种类型的异常值。第一种是 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} {!s:6} {!s:6} {!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
try:
print 'x**2 =', x**2
except OverflowError, 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()。 转换为整数 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 = ' '.join(['{:5.1f}'] * 5)
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。 其他表示 modf() 取一个浮点数，并返回一个 tuple，其中包含这个输入值的小数和整数部分。
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('x', 'm', 'e')
print '{:-^7} {:-^7} {:-^7}'.format('', '', '')
for m, e in [ (0.8, -3),
(0.5, 0),
(0.5, 3)
]:
x = math.ldexp(m, e)
print '{:7.2f} {:7d} {:7.2f}'.format(m, e, x)
使用与 frexp() 相同的公式，ldexp() 取尾数和指数值作为参数，将返回一个浮点数。 正号和负号 一个数的绝对值就是不带正负号的本值。使用 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('', '', '', '', '',)
for f in [ -1.0,
0.0,
1.0,
float('-inf'),
float('inf'),
float('-nan'),
float('nan'),
]:
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 与其他值直接比较。 常用计算 在二进制浮点数内存中表示精确值很有难度。有些值无法准确地表示，而且一个值如果通过反复计算来处理，这样处理越频繁就越容易引入表示错误。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, err:
print 'Error computing factorial(%s):' % 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, err:
print 'Error computing gamma(%s):' % 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, err:
print 'Error computing lgamma(%s):' % i, err
使用 lgamma() 会比使用 gamma() 的结果单独计算对数更精确。 求模操作符 (%) 会计算一个除法表达式的余数（例如，5%2=1）。Python 语言内置的这个操作符可以很好地处理整数，但是与很多其他浮点数运算类似，中间计算可能导致表示问题，进一步造成数据丢失。fmod() 可以为浮点值提供一个更精确的实现。
import math
print '{:^4} {:^4} {:^5} {:^5}'.format('x', 'y', '%', 'fmod')
print '---- ---- ----- -----'
for x, y in [ (5, 2),
(5, -2),
(-5, 2),
]:
print '{:4.1f} {:4.1f} {:5.2f} {:5.2f}'.format(
x,
y,
x % y,
math.fmod(x, y),
)
还有一点很可能经常产生混淆，fmod() 计算模所使用的算法与 % 使用的算法也有所不同，所以结果的符号不同。 指数和对数 指数生长曲线在经济学、物理学和其他科学中经常出现。Python 有一个内置的幂运算符（**），不过如果需要将一个可调用函数作为另一个的参数，可能需要用到 pow()。
import math
for x, y in [
# 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),
]:
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, 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,
)
输出中末尾有 * 的行突出强调了不精确的值。 loglp() 会计算 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 'loglp(x):', math.log1p(x)
对于非常接近于 0 的 x，loglp() 会更为精确，因为它使用的算法可以补偿由初始加法带来的取整错误。 exp() 会计算指数函数（e**x）。
import math
x = 2
fmt = '%.20f'
print fmt % (math.e ** 2)
print fmt % math.pow(math.e, 2)
print fmt % math.exp(2)
与其他特殊情况函数类似，exp() 使用的算法可以生成比与之等价的通用函数 math.pow(math.e, x) 更为精确的结果。 expml() 与 loglp() 正相反，会计算 e**x - 1。
import math
x = 0.0000000000000000000000001
print x
print math.exp(x) - 1
print math.expm1(x)
类似于 loglp()，x 值很小时，如果单独完成减法会损失精度。 角 尽管我们讨论角时更经常用到度，但弧度才是科学和数学领域中的标准角度度量单位。弧度是在圆心相交的两条线所创建的角，其终点落在圆的圆周上，终点之间相距一个弧度。 圆周计算为 2πr，所以弧度与 π（这是三角函数计算中经常出现的一个值）之间存在一个关系。这个关系使得三角学和微积分中都使用了弧度，因为利用弧度可以得到更紧凑的公式。 要把度转换为弧度，可以使用 radians()。
import math
print '{:^7} {:^7} {:^7}'.format('Degrees', 'Radians', 'Expected')
print '{:^7} {:^7} {:^7}'.format('', '', '')
for deg, expected in [ ( 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),
]:
print '{:7d} {:7.2f} {:7.2f}'.format(deg,
math.radians(deg),
expected,
)
转换公式为 rad = deg * π / 180。 要从弧度转换为度，可以使用 degrees()。
import math
print '{:^8} {:^8} {:^8}'.format('Radians', 'Degrees', 'Expected')
print '{:-^8} {:-^8} {:-^8}'.format('', '', '')
for rad, expected in [ (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.2f} {:8.2f} {:8.2f}'.format(rad,
math.degrees(rad),
expected,
)
具体转换公式为 deg=rad * 180 / π。 三角函数 三角函数将三角形中的角与其边长相关联。在有周期性质的公式中经常出现三角函数，如谐波或圆周运动，或者处理角时也经常用到三角函数。标准库中所有三角函数的角参数都表示为弧度。 给定一个直角三角形中的角，其正弦是对边长度与斜边长度之比（sinA = opposite/hypotenuse）。余弦是邻边长度与斜边长度之比（cosA = adjacent/hypotenuse）。正切是对边与邻边之比（tanA = opposite/adjacent）。
import math
print 'Degrees Radians Sine Cosine Tangent'
print '------- ------- ------- -------- -------'
fmt = ' '.join(['%7.2f'] * 5)
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 % (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('', '', '')
for x, y in [ # 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
]:
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(
'', '', '', '', '',
)
for (x1, y1), (x2, y2) in [ ((5, 5), (6, 6)),
((-6, -6), (-5, -5)),
((0, 0), (3, 4)), # 3-4-5 truanle
((-1, -1), (2, 3)), # 3-4-5 triangle
]:
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' % (r, math.asin(r))
print 'arccosine(%.1f) = %5.2f' % (r, math.acos(r))
print 'arctangent(%.1f) = %5.2f' % (r, math.atan(r))
1.57 大约等于 π / 2，或 90 度，这个角的正弦为 1，余弦为 0。 双曲函数 双曲函数经常出现在线性微分方程中，处理电磁场、流体力学、狭义相对论和其他高级物理和数学问题时常会用到。
import math
print '{:^6} {:^6} {:^6} {:^6}'.format(
'X', 'sinh', 'cosh', 'tanh',
)
print '{:-^6} {:-^6} {:-^6} {:-^6}'.format('', '', '', '')
fmt = ' '.join(['{:6.4f}'] * 4)
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()。 特殊函数 统计学中经常用到高斯误差函数（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)。 补余误差函数是 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 值很小，erfc() 实现可以避免从 1 减时可能带来的精度误差。
扫一扫
51万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
