[转载] [python标准库]math—

参考链接： Python数学库| expm1()方法

[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,

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(

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 减时可能带来的精度误差。

[转载] [python标准库]math——数学函数相关推荐

python标准库math用来计算平方根的函数_《Python程序设计方案》题库
< Python 程序设计>题库一.填空题第一章基础知识 1 . Python 安装扩展库常用的是 _______ 工具.( pip ) 2 . Python 标准库 math 中用 ...
python标准库math用来计算平方根的函数_《Python程序设计》试试题题库
WORD 格式可编辑 < Python 程序设计>题库一.填空题第一章基础知识 1 . Python 安装扩展库常用的是 _______ 工具.( pip ) 2 . Python ...
python标准库math中用来计算平方根的函数是_2020超星尔雅网课透过性别看世界完整满分见面课答案...
壮医药线点灸之所以能治疗厌食症是因为其具有( )的功效. 智慧职教: 下列药物中,从肾脏排泄最少的是 [A1/A2型题]葡萄胎清宫术前备用物品中哪项不需要设循环队列的存储空间为Q(1:m),初始状态 ...
python标准库math中用来计算平方根的函数_python考试复习题库
内容来自用户:魔翼双飞237 一. 填空e68a843231313335323631343130323136353331333433646430题1. Python安装扩展库常用的是_工具.(pip) ...
[转载] python标准库系列教程(三)——operator库详细教程
参考链接: Python中的Inplace运算符| 2(ixor(),iand(),ipow()等) python进阶教程机器学习深度学习长按二维码关注进入正文 Python基础学习:oper ...
python标准库random中函数的作用_Python随机函数库random的使用方法详解
Python随机函数库random的使用方法详解前言众所周知,python拥有丰富的内置库,还支持众多的第三方库,被称为胶水语言,随机函数库random,就是python自带的标准库,他的用法极为 ...
python标准库math中用来实现上取整_python中取整
向上取整定义:大于或等于 x 的最大整数 math.ceil(x) 向上取整运算为Ceiling,用数学符号??表示 1 2 3 4 5 6>>> import math # py ...
python标准库math中计算平方根的函数_16 Python 标准库之 math 模块 - Python 进阶应用教程...
1. 前言 math 模块中包含了各种浮点运算函数,包括: 函数功能 floor 向下取整 ceil 向上取整 pow 指数运算 fabs 绝对值 sqrt 开平方 modf 拆分小数和整数 fsu ...
python标准库math中sin函数的参数单位是角度吗_弧度 - math.h中的三角函数，参数是弧度，不是角度...
在数学和物理中,弧度是角的度量单位.它是由国际单位制导出的单位,单位缩写是rad. 定义1:弧长等于半径的弧,其所对的圆心角为1弧度.(即两条射线从圆心向圆周射出,形成一个夹角和夹角正对的一段弧.当这 ...

[转载] [python标准库]math——数学函数

[转载] [python标准库]math——数学函数相关推荐

最新文章

热门文章