isfinite(x)
如果 x 既不是无穷大也不是NaN，则返回 True ，否则返回 False 。（注意 0.0 被认为是有限的。）
>>>from math import isfinite,nan,inf
>>>isfinite(nan)
False
>>>isfinite(inf)
False
>>>isfinite(-inf)
False
>>>isfinite(0.0)
True
isinf(x)
如果 x 是正或负无穷大，则返回 True ，否则返回 False 。
>>>from math import isinf,nan,inf
>>>isinf(inf)
True
>>>isinf(-inf)
True
>>>isinf(nan)
False
>>>isinf(0.0)
False
isnan(x)
如果 x 是 NaN（不是数字），则返回 True ，否则返回 False 。
>>>from math import isnan,nan,inf
>>>isnan(inf)
False
>>>isnan(-inf)
False
>>>isnan(nan)
True
>>>isnan(0.0)
False
isqrt(n)
返回非负整数 n 的整数平方根。这就是对 n 的实际平方根向下取整，或者相当于使得 a² ≤ n 的最大整数 a。
>>>from math import isqrt
>>>isqrt(10)
3
对于某些应用来说，可以更适合取值为使得 n ≤ a² 的最小整数 a ，或者换句话说就是 n 的实际平方根向上取整。对于正数 n，这可以使用 a = 1 + isqrt(n - 1) 来计算。
>>>1+isqrt(10-1)
4
lcm(*integers)
返回给定的整数参数的最小公倍数。如果所有参数均非零，则返回值将是为所有参数的整数倍的最小正整数。如果参数之一为零，则返回值为 0。不带参数的 lcm() 返回 1。
>>>from math import lcm
>>>lcm(),lcm(4,6,18,0),lcm(4,6,18)
(1, 0, 36)
ldexp(x, i)
返回 x * (2**i) 。基本上用作函数 frexp() 的反函数。
>>>from math import ldexp,frexp
>>>frexp(123.456)
(0.9645, 7)
>>>ldexp(0.9645, 7)
123.456
modf(x)
返回 x 的小数和整数部分。两个值都是与 x 符号相同的浮点数。
>>>from math import modf
>>>modf(123)
(0.0, 123.0)
>>>modf(-123.456)
(-0.45600000000000307, -123.0)
>>>from fractions import Fraction
>>>modf(Fraction(50,3))
(0.6666666666666679, 16.0)
nextafter(x, y)
返回 x 趋向于 y 的最接近的浮点数值。如果 x 等于 y 则返回 y。
>>>from math import nextafter,inf,copysign
>>>nextafter(0.0,inf) #趋向正无穷。
5e-324
>>>nextafter(0.0,-inf) #趋向负无穷。
-5e-324
>>>nextafter(1.0,0.0) #趋向零。
0.9999999999999999
>>>nextafter(-1.0,0.0) #趋向零。
-0.9999999999999999
>>>nextafter(1.0, copysign(inf, 1.0)) #背向零。
1.0000000000000002
>>>nextafter(-1.0, copysign(inf, -1.0)) #背向零。
-1.0000000000000002
>>>nextafter(3.14159,3.14159)
3.14159
另请参阅ulp()。
perm(n, k=None)
返回不重复且有顺序地从 n 项中选择 k 项的方式总数。即排列公式：
当 k <= n 时取值为 n! / (n - k)!；当 k > n 时取值为零。
如果 k 未指定或为 None，则 k 默认值为 n 并且函数将返回 n!。
如果任一参数不为整数或是负数则会引发ValueError。
>>>from math import perm
>>>perm(10),10*9*8*7*6*5*4*3*2*1
(3628800, 3628800)
>>>perm(10,5),10*9*8*7*6,10*9*8*7*6*5*4*3*2*1//(5*4*3*2*1)
(30240, 30240, 30240)
>>>perm(10.0)
3628800
>>>perm(10.1)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: factorial() only accepts integral values
>>>perm(10,-5)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: k must be a non-negative integer
>>>perm(10,10)
3628800
>>>perm(10,0)
1
>>>perm(10,11)
0
prod(iterable, *, start=1)
计算输入的 iterable 中所有元素的积。积的默认值 start 为 1。
当可迭代对象为空时，返回起始值。此函数特别针对全数字值序列，如果序列中有非数字元素会抛出TypeError异常。
>>>from math import prod
>>>prod(range(1,11))
3628800
>>>prod([1,2.3,9,4.5])
93.14999999999999
>>>prod([1,2.3,9,4.5],start=2)
186.29999999999998
>>>prod([1,2.3,9,4.5,"完成")
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: can't multiply sequence by non-int of type 'float'
>>>prod([])
1
>>>prod([],start=2)
2
remainder(x, y)
返回 x 相对于 y 的最接近余数（可正可负，不受限于y的符号）。对于有限 x 和有限非零 y ，结果是差 x - n*y ，其中 n 是与商 x / y 最接近的整数。如果 x / y 恰好位于两个连续整数之间，则将最接近的偶数用作 n 。 因此，余数 r = remainder(x, y)总是满足 abs(r) <= 0.5 * abs(y)。
>>>from math import remainder,fmod,inf
>>>remainder(19,5), fmod(19,5)
(-1.0, 4.0)
>>>remainder(19,2),fmod(19,2)
(-1.0, 1.0)
remainder(x, math.inf) 对于任何有限 x 都是 x ，而 remainder(x, 0) 和 remainder(math.inf, x)抛出ValueError异常。适用于任何非NaN的 x 。如果余数运算的结果为零，则该零将具有与 x 相同的符号。
>>>remainder(19,inf)
>>>19.0
>>>remainder(19,0)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: math domain error
>>>remainder(inf,5)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: math domain error
>>>remainder(-18,9)
-0.0
>>>remainder(-18,-9)
-0.0
在使用IEEE 754二进制浮点的平台上，此函数的返回结果始终能全部表示，不会引入舍入误差。
trunc(x)
返回去除x小数部分，只留下整数部分。trunc() 对于正的 x 相当于 floor() ，对于负的 x 相当于 ceil() 。如果 x 是普通对象，委托给 x.__trunc__ 方法，它应该返回一个 Integral 值。
>>>from math import trunc,floor,ceil
>>>trunc(123.56),floor(123.56),ceil(123.56),round(123.56)
(123, 123, 124, 124)
>>>trunc(-123.56),floor(-123.56),ceil(-123.56),round(-123.56)
(-123, -124, -123, -124)
·
·
·
·
·
class TruncTest: def __init__(self,num): self.num=num def __trunc__(self): return round(self.num*100)
>>>trunc(TruncTest(0.8899)),trunc(0.8899*100)
(89, 88)
ulp(x)
"Unit in the Last Place" 的缩写。返回浮点数 x 的最小有效比特位的值。对于64位浮点数，最小有效比特位就是第53位。由于指数的不同，它表示的值不同。可以认为这个值是这个浮点数的“二进制精度”。
如果 x 是 NaN (非数字)，则返回 NaN。
如果 x 为负数，则返回 ulp(-x)。
如果 x 为正数，则返回 ulp(x)。
如果 x 等于零，则返回非正规化的可表示最小正浮点数 (小于正规化的 最小正浮点数sys.float_info.min)。
如果 x 等于可表示最大正浮点数，则返回 x 的最低有效比特位的值，使得小于 x 的第一个浮点数为 x - ulp(x)。
在其他情况下 (x 是一个有限的正数)，则返回 x 的最低有效比特位的值，使得大于 x 的第一个浮点数为 x + ulp(x)。
>>>from math import ulp,nan,nextafter,inf
>>>ulp(2)
4.440892098500626e-16
>>>ulp(4)
8.881784197001252e-16
>>>2*ulp(2) == ulp(4)
True
>>>ulp(0.25)
5.551115123125783e-17
>>>ulp(0.125)
2.7755575615628914e-17
>>>ulp(0.25)/2 == ulp(0.125)
True
>>>ulp(nan)
nan
>>>ulp(-2), ulp(-2) == ulp(2)
(4.440892098500626e-16, True)
>>>import sys
>>>ulp(0.0),sys.float_info.min,sys.float_info.epsilon
(5e-324, 2.2250738585072014e-308, 2.220446049250313e-16)
>>>ulp(sys.float_info.max),sys.float_info.max,nextafter(inf,0.0)
(1.99584030953472e+292,1.7976931348623157e+308,1.7976931348623157e+308)
>>>nextafter(sys.float_info.max,0.0)==sys.float_info.max-ulp(sys.float_info.max)
True
>>>nextafter(1,inf) == 1+ulp(1)
True
>>>ulp(1) == sys.float_info.epsilon
True
另请参阅math.nextafter() 和 sys.float_info.epsilon。
对于ceil() ，floor() 和 modf() 函数，请注意所有足够大的浮点数都是精确整数。Python浮点数通常不超过53位的精度（与标准C语言的double类型相同），在这种情况下，任何浮点数 x 当 abs(x) >= 2**52 必然没有小数位，这时这几个函数就失去意义了。
>>>from math import ceil,floor,modf
>>>ceil(1.23e25)
12300000000000000276824064
>>>floor(1.23e25)
12300000000000000276824064
>>>modf(1.23e25)
(0.0, 1.23e+25)