主要是math模块包含的函数以及一些与数学操作有关的内置函数的总结
 

#向上取整

import math

x = 5.5
print(math.ceil(x))

>>>6
 

# 向下取整

import math

x = 5.5
print(math.floor(x))

>>>5
 

# 次方

import math

x = 5
math.pow(5,2)

>>> 25.0

# 平方

x = 5
x ** x

>>> 25
 
EX：返回的是浮点数
 

# 绝对值

import math

x = -5
math.fabs(x)

>>> 5.0

# 内置函数求绝对值

x = -5
abs(x)

>>> 5
 
EX：math.fabs与内置函数abs的区别在于前者返回的是浮点数，后者返回值根据被操作数决定
 

# 求和

import math

list_01 = [1,2,3,4,5]
math.fsum(list_01)

>>> 15.0

# 内置函数sum求和

sum([1,2,3,4,5])

>>> 15
 

# 拆分数：将浮点数的整数部分和小数部分拆分成两个部分并作为元组形式返回

import math

x,y = math.modf(5.5)

>>> X = 5.0    Y = 0.5
 

# 符号替换：将第二个参数的符号作为第一个参数的符号并返回第一个数

import math

math.copysign(-4396,4396)

>>> 4396
 

# 四舍五入

round(5.5)

>>> 6
 
 

math — Mathematical functions
 


 
文章目录
 
math — Mathematical functions
数论与表示函数
幂函数与对数函数
三角函数
角度转换
双曲函数
特殊函数
常量
Math skill
1. average - 平均值
2. average_by - 函数映射后的平均值
3. clamp_number
4. digitize - 转数组
5. factorial - 阶乘
6. fibonacci - 斐波那契数列
7. gcd - 最大公约数
8. in_range - 判断范围
9. is_divisible - 整除
10. is_even - 偶数
11. is_odd - 奇数
12. 最小公倍数
13. max_by - 函数映射后的最大值
14. median - 中值
15. min_by - 函数映射后的最小值
16. rads_to_degrees - 弧度转角度
17. sum_by - 求和
   
  
 

 
数论与表示函数
 
 
math.ceil(x)
 
返回 x 的向上取整，即大于或者等于 x 的最小整数。
 
如果 x 不是一个浮点数，则委托 x.__ceil__(), 返回 Integral 类的值。
 
 
math.copysign(x, y)
 
返回一个基于 x 的绝对值和 y 的符号的浮点数。
 
copysign(1.0, -0.0) 返回 -1.0.
 
 
math.fabs(x)
 
返回 x 的绝对值。
 
 
math.factorial(x)
 
以一个整数返回 x 的阶乘。
 
如果 x 不是整数或为负数时则将引发 ValueError。
 
 
math.floor(x)
 
返回 x 的向下取整，小于或等于 x 的最大整数。
 
如果 x 不是浮点数，则委托 x.__floor__() ，它应返回 Integral 值。
 
 
math.fmod(x, y)
 
返回 fmod(x, y) ，由平台C库定义。请注意，Python表达式 x % y 可能不会返回相同的结果。C标准的目的是 fmod(x, y) 完全（数学上；到无限精度）等于 x - n*y 对于某个整数 n ，使得结果具有 与 x 相同的符号和小于 abs(y) 的幅度。Python的 x % y 返回带有 y 符号的结果，并且可能不能完全计算浮点参数。
 
例如， fmod(-1e-100, 1e100) 是 -1e-100 ，但Python的 -1e-100 % 1e100 的结果是 1e100-1e-100 ，它不能完全表示为浮点数，并且取整为令人惊讶的 1e100 。
 
出于这个原因，函数 fmod() 在使用浮点数时通常是首选，而Python的 x % y 在使用整数时是首选。
 
 
math.frexp(x)
 
返回 x 的尾数和指数作为对(m, e)。 m 是一个浮点数， e 是一个整数，正好是 x == m * 2**e 。
 
如果 x 为零，则返回 (0.0, 0) ，否则返回 0.5 <= abs(m) < 1 。
 
这用于以可移植方式“分离”浮点数的内部表示。
 
 
math.fsum(iterable)
 
返回迭代中的精确浮点值。通过跟踪多个中间部分和来避免精度损失
 
>>> sum([.1, .1, .1, .1, .1, .1, .1, .1, .1, .1])
0.9999999999999999
>>> fsum([.1, .1, .1, .1, .1, .1, .1, .1, .1, .1])
1.0
 
 
math.gcd(a, b)
 
返回整数 a 和 b 的最大公约数。如果 a 或 b 之一非零，则 gcd(a, b) 的值是能同时整除 a 和 b 的最大正整数。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 。默认容差为 1e-09，确保两个值在大约9位十进制数字内相同。 rel_tol 必须大于零。abs_tol 是最小绝对容差 —— 对于接近零的比较很有用。 abs_tol 必须至少为零。
 
 
math.isfinite(x)
 
如果 x 既不是无穷大也不是NaN，则返回 True ，否则返回 False 。
 
 
math.isinf(x)
 
如果 x 是正或负无穷大，则返回 True ，否则返回 False 。
 
 
math.isnan(x)
 
如果 x 是 NaN（不是数字），则返回 True ，否则返回 False 。
 
 
math.ldexp(x, i)
 
返回 x * (2**i) 。 这基本上是函数 frexp()的反函数。
 
 
math.modf(x)
 
返回 x 的小数和整数部分。两个结果都带有 x 的符号并且是浮点数。
 
 
math.remainder(x, y)
 
返回 IEEE 754 风格的 x 相对于 y 的余数。对于有限 x 和有限非零 y ，这是差异 x - n*y ，其中 n 是与商 x /y 的精确值最接近的整数。如果 x / y 恰好位于两个连续整数之间，则最近的 * even* 整数用于 n 。 余数 r =remainder(x, y) 因此总是满足 abs(r) <= 0.5 * abs(y) 。
 
特殊情况遵循IEEE 754：特别是 remainder(x, math.inf) 对于任何有限 x 都是 x ，而 remainder(x, 0) 和 remainder(math.inf, x) 引发 ValueError 适用于任何非NaN的 x 。如果余数运算的结果为零，则该零将具有与 x 相同的符号。
 
在使用IEEE 754二进制浮点的平台上，此操作的结果始终可以完全表示：不会引入舍入错误。3.7 新版功能.
 
 
math.trunc(x)
 
返回 Real 值 x 截断为 Integral（通常是整数）。 委托给x.__trunc__()。
 
 
幂函数与对数函数
 
 
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；
 
 
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 次幂。
 
特别是， 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.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.hypot(x, y)
 
返回欧几里德范数， sqrt(x*x + y*y) 。 这是从原点到点 (x, y) 的向量长度。
 
 
math.sin(x)
 
返回 x 弧度的正弦值。
 
 
math.tan(x)
 
返回 x 弧度的正切值。
 
 
角度转换
 
 
math.degrees(x)
 
将角度 x 从弧度转换为度数。
 
 
math.radians(x)
 
将角度 x 从度数转换为弧度。
 
 
双曲函数
 
双曲函数 是基于双曲线而非圆来对三角函数进行模拟。
 
 
math.acosh(x)
 
返回 x 的反双曲余弦值。
 
 
math.asinh(x)
 
返回 x 的反双曲正弦值。
 
 
math.atanh(x)
 
返回 x 的反双曲正切值。
 
 
math.cosh(x)
 
返回 x 的双曲余弦值。
 
 
math.sinh(x)
 
返回 x 的双曲正弦值。
 
 
math.tanh(x)
 
返回 x 的双曲正切值。
 
 
特殊函数
 
 
math.erf(x)
 
返回 x 处的 error function 。erf() 函数可用于计算传统的统计函数。
 
 
math.erfc(x)
 
返回 x 处的互补误差函数。 互补错误函数 定义为 1.0 - erf(x)。 它用于 x 的大值，从其中减去一个会导致 有效位数损失。
 
 
math.gamma(x)
 
返回 x 处的 伽马函数 值。
 
 
math.lgamma(x)
 
返回Gamma函数在 x 绝对值的自然对数。
 
 
常量
 
 
math.pi
 
数学常数 π = 3.141592…，精确到可用精度。
 
 
math.e
 
数学常数 e = 2.718281…，精确到可用精度。
 
 
math.tau
 
数学常数 τ = 6.283185…，精确到可用精度。
 
Tau 是一个圆周常数，等于 2π，圆的周长与半径之比。
 
 
math.inf
 
浮点正无穷大。 （对于负无穷大，使用 -math.inf 。）相当于float('inf') 的输出。
 
 
math.nan
 
浮点“非数字”（NaN）值。 相当于 float('nan') 的输出。
 
 
Math skill
 
1. average - 平均值
 
返回两个或多个值的平均值
 
Returns the average of two or more numbers.
 
Use sum() to sum all of the args provided, divide by len(args).
 
def average(*args):
    return sum(args, 0.0) / len(args)
 Examples 
average(*[1, 2, 3]) # 2.0
average(1, 2, 3) # 2.0
 
2. average_by - 函数映射后的平均值
 
返回一个列表中所有经过函数处理的元素的平均值
 
Returns the average of a list, after mapping each element to a value using the provided function.
 
Use map() to map each element to the value returned by fn.
 Use sum() to sum all of the mapped values, divide by len(lst).
 
def average_by(lst, fn=lambda x: x):
    return sum(map(fn, lst), 0.0) / len(lst)
 Examples 
average_by([{ 'n': 4 }, { 'n': 2 }, { 'n': 8 }, { 'n': 6 }], lambda x: x['n']) # 5.0
 
3. clamp_number
 
将num限制在边界值a和b指定的范围内。
 
如果num在此范围内，则返回num。
 
否则，返回范围内最接近的数字。
 
Clamps num within the inclusive range specified by the boundary values a and b.
 
If num falls within the range, return num.
 Otherwise, return the nearest number in the range.
 
def clamp_number(num,a,b):
    return max(min(num, max(a,b)),min(a,b))
 Examples 
clamp_number(2, 3, 5) # 3
clamp_number(1, -1, -5) # -1
 
4. digitize - 转数组
 
将一个数转换为数字数组。
 
Converts a number to an array of digits.
 
Use map() combined with int on the string representation of n and return a list from the result.
 
def digitize(n):
    return list(map(int, str(n)))
 Examples 
digitize(123) # [1, 2, 3]
 
5. factorial - 阶乘
 
计算数字的阶乘
 
Calculates the factorial of a number.
 
Use recursion.
 If num is less than or equal to 1, return 1.
 Otherwise, return the product of num and the factorial of num - 1.
 Throws an exception if num is a negative or a floating point number.
 
def factorial(num):
    if not ((num >= 0) and (num % 1 == 0)):
      raise Exception(
        f"Number( {num} ) can't be floating point or negative ")
    return 1 if num == 0 else num * factorial(num - 1)
 Examples 
factorial(6) # 720
 
6. fibonacci - 斐波那契数列
 
生成斐波那契数列
 
Generates an array, containing the Fibonacci sequence, up until the nth term.
 
Starting with 0 and 1, use list.apoend() to add the sum of the last two numbers of the list to the end of the list, until the length of the list reaches n.
 If n is less or equal to 0, return a list containing 0.
 
def fibonacci(n):
    if n <= 0:
      return [0]

    sequence = [0, 1]
    while len(sequence) <= n:
      next_value = sequence[len(sequence) - 1] + sequence[len(sequence) - 2]
      sequence.append(next_value)

    return sequence
 Examples 
fibonacci(7) # [0, 1, 1, 2, 3, 5, 8, 13]
 
7. gcd - 最大公约数
 
计算数字列表的最大公约数。
 
Calculates the greatest common divisor of a list of numbers.
 
Use reduce() and math.gcd over the given list.
 
from functools import reduce
import math

def gcd(numbers):
    return reduce(math.gcd, numbers)
 Examples 
gcd([8,36,28]) # 4
 
8. in_range - 判断范围
 
检查给定数字是否在给定范围内
 
Checks if the given number falls within the given range.
 
Use arithmetic comparison to check if the given number is in the specified range.
 If the second parameter, end, is not specified, the range is considered to be from 0 to start.
 
def in_range(n, start, end = 0):
    if (start > end):
      end, start = start, end
    return start <= n <= end
 Examples 
in_range(3, 2, 5); # True
in_range(3, 4); # True
in_range(2, 3, 5); # False
in_range(3, 2); # False
 
9. is_divisible - 整除
 
检查第一个数值参数是否可被第二个数值参数整除。
 
Checks if the first numeric argument is divisible by the second one.
 
Use the modulo operator (%) to check if the remainder is equal to 0.
 
def is_divisible(dividend, divisor):
    return dividend % divisor == 0
 Examples 
is_divisible(6, 3) # True
 
10. is_even - 偶数
 
如果给定数字为偶数，则返回’true’，否则返回’false’。
 
Returns True if the given number is even, False otherwise.
 
Checks whether a number is odd or even using the modulo (%) operator.
 Returns True if the number is even, False if the number is odd.
 
def is_even(num):
    return num % 2 == 0
 Examples 
is_even(3) # False
 
11. is_odd - 奇数
 
如果给定数字为偶数，则返回’true’，否则返回’false’。
 
Returns True if the given number is odd, False otherwise.
 
Checks whether a number is even or odd using the modulo (%) operator.
 Returns True if the number is odd, False if the number is even.
 
def is_odd(num):
    return num % 2 != 0
 Examples 
is_odd(3) # True
 
12. 最小公倍数
 
返回两个或多个数字的最小公倍数。
 
Returns the least common multiple of two or more numbers.
 
Define a function, spread, that uses either list.extend() or list.append() on each element in a list to flatten it.
 Use math.gcd() and lcm(x,y) = x * y / gcd(x,y) to determine the least common multiple.
 
from functools import reduce
import math

def spread(arg):
    ret = []
    for i in arg:
      if isinstance(i, list):
        ret.extend(i)
      else:
        ret.append(i)
    return ret

def lcm(*args):
    numbers = []
    numbers.extend(spread(list(args)))

    def _lcm(x, y):
        return int(x * y / math.gcd(x, y))

    return reduce((lambda x, y: _lcm(x, y)), numbers)
 Examples 
lcm(12, 7) # 84
lcm([1, 3, 4], 5) # 60
 
13. max_by - 函数映射后的最大值
 
在使用所提供的函数将每个元素映射到每一个值后返回一个列表的最大值。
 
Returns the maximum value of a list, after mapping each element to a value using the provided function.
 
Use map() with fn to map each element to a value using the provided function, use max() to return the maximum value.
 
def max_by(lst, fn):
    return max(map(fn,lst))
 Examples 
max_by([{ 'n': 4 }, { 'n': 2 }, { 'n': 8 }, { 'n': 6 }], lambda v : v['n']) # 8
 
14. median - 中值
 
查找列表中元素的中值。
 
Finds the median of a list of numbers.
 
Sort the numbers of the list using list.sort() and find the median, which is either the middle element of the list if the list length is odd or the average of the two middle elements if the list length is even.
 
def median(list):
    list.sort()
    list_length = len(list)
    if list_length%2==0:
  	    return (list[int(list_length/2)-1] + list[int(list_length/2)])/2
    else:
        return list[int(list_length/2)]
 Examples 
median([1,2,3]) # 2
median([1,2,3,4]) # 2.5
 
15. min_by - 函数映射后的最小值
 
在使用所提供的函数将每个元素映射到每一个值后返回一个列表的最小值。
 
Returns the minimum value of a list, after mapping each element to a value using the provided function.
 
Use map() with fn to map each element to a value using the provided function, use min() to return the minimum value.
 
def min_by(lst, fn):
    return min(map(fn,lst))
 Examples 
min_by([{ 'n': 4 }, { 'n': 2 }, { 'n': 8 }, { 'n': 6 }], lambda v : v['n']) # 2
 
16. rads_to_degrees - 弧度转角度
 
将角度从弧度转换为角度。
 
Converts an angle from radians to degrees.
 
Use math.pi and the radian to degree formula to convert the angle from radians to degrees.
 
import math

def rads_to_degrees(rad):
    return (rad * 180.0) / math.pi
 Examples 
import math
rads_to_degrees(math.pi / 2) # 90.0
 
17. sum_by - 求和
 
使用提供的函数将每个元素映射到值后，返回列表的和。
 
Returns the sum of a list, after mapping each element to a value using the provided function.
 
Use map() with fn to map each element to a value using the provided function, use sum() to return the sum of the values.
 
def sum_by(lst, fn):
    return sum(map(fn,lst))
 Examples 
sum_by([{ 'n': 4 }, { 'n': 2 }, { 'n': 8 }, { 'n': 6 }], lambda v : v['n']) # 20

1.math简介
>>>import math #导入math模块
>>>dir(math) #这句可查看所有函数名列表
>>>help(math) #查看具体定义及函数原型
2.常用函数
acos(x) # Return the arc cosine (measured in radians) of x.
asin(x) # Return the arc sine (measured in radians) of x.
atan(x) # Return the arc tangent (measured in radians) of x.
atan2(y, x) # Return the arc tangent (measured in radians) of y/x.
# Unlike atan(y/x), the signs of both x and y are considered.
ceil(x) # Return the ceiling of x as a float.
# This is the smallest integral value >= x.
cos(x) # Return the cosine of x (measured in radians).
cosh(x) # Return the hyperbolic(双曲线的) cosine of x.
degrees(x) # converts angle x from radians(弧度) to degrees
exp(x) # Return e raised to the power of x.
fabs(x) # Return the absolute value of the float x.
floor(x) # Return the floor of x as a float.
# This is the largest integral value <= x.
fmod(x,y) # Return fmod(x, y), according to platform C. x % y may differ.
frexp(x) # Return the mantissa and exponent of x, as pair (m, e).
# m is a float and e is an int, such that x = m * 2.**e.
# If x is 0, m and e are both 0. Else 0.5 <= abs(m) < 1.0.
hypot(x,y) # Return the Euclidean distance, sqrt(x*x + y*y).
ldexp(x, i) # x * (2**i)
log(x[, base]) # the logarithm of x to the given base.
# If the base not specified, returns the natural logarithm (base e) of x.
log10(x) # the base 10 logarithm of x.
modf(x) # Return the fractional and integer parts of x. Both results carry the sign
# of x. The integer part is returned as a real.
pow(x,y) # Return x**y (x to the power of y).
radians(x) # converts angle x from degrees to radians
sin(x) # Return the sine of x (measured in radians).
sinh(x) # Return the hyperbolic sine of x.
sqrt(x) # Return the square root of x.
tan(x) # Return the tangent of x (measured in radians).
tanh(x) # Return the hyperbolic tangent of x.
另外该模块定义了两个常量:
e = 2.7182818284590451
pi = 3.1415926535897931

       math模块中定义了一些数学函数。由于这个模块属于编译系统自带，因此它可以被无条件调用。该模块还提供了与用标准C定义的数学函数的接口。
 
       要注意的是，这些函数无法应用于复数，但是在cmath模块中定义的同名函数可以支持复数运算，当然也会为此付出一定的性能代价。为什么会设置同名的函数却会有是否支持复数的区别，这是因为大多数用户完全不需要复数方面的操作，因此对于他们来讲，理解函数就会有不必要的麻烦。接受一个例外而不是一个复数结果使得参数被设置为复数这个意外更加容易被察觉，那么编程者就可以再次确认以下为什么要定义并在这里产生它。
 
       以下的函数是该模块所提供的。除非明确指出，否则所有返回值都是浮点数。
 
1. 数论函数和表示函数
 
math. ceil(x)
 
       返回x的最大值，这个最大值是大于或等于x的最小整数。如果x不是浮点数的话，将使用x.__ceil__()替代返回一个整数值。
 
 
 
math. copysign(x, y)
 
       返回一个浮点数，该浮点数的绝对值与x相同，正负性与y相同。如果运行平台支持带符号的零，copysign(1.0, -0.0)将会返回-1.0.
 
 
 
math. factorial(x)
 
       返回x的绝对值。
 
 
 
math. factorial(x)
 
       返回x的阶乘值。如果x不是整数或者为负数，抛出ValueError。
 
 
 
math. floor(x)
 
       返回x的最小值，该最小值为小于等于x的最大整数。
 
 
 
math. fmod(x, y)
 
       按照平台C库的定义返回fmod（x，y）。请注意，Python表达式x％y可能不会返回相同的结果。标准C的意图是对于某个整数n，fmod（x，y）完全（在数学上达到无限精度）等于x-n * y，使得结果的符号与x相同，幅度小于abs(Y)。Python的x％y返回一个带有y的符号的结果，并且对于float参数可能不是完全可计算的。例如，fmod（-1e-100，1e100）是-1e-100，但是Python的-1e-100％1e100的结果是1e100-1e-100，它不能完全表示为浮点数，并且令人惊讶1e100。出于这个原因，函数fmod（）在使用浮点数时通常是首选，而在使用整数时，Python的x％y是首选。
 
 
 
math. frexp(x)
 
       以(m, e)数对的形式返回x的尾数和指数。m是一个浮点数，而e是一个整数，其类似于x == m*2**e。如果x是0，返回(0.0, 0);否则，0.5<=abs(m)<1。该函数使得分解浮点数的内部表达形式变得简单高效。
 
 
 
math.fsum(iterable)
 
       将可迭代对象iterable内的元素值精确地相加在一起，返回一个浮点数形式的和。该函数可以有效避免浮点数求和时的精度损失。
 
>>>sum([.1, .1, .1, .1, .1, .1, .1, .1, .1, .1])
 
0.9999999999999999
 
>>>fsum([.1, .1, .1, .1, .1, .1, .1, .1, .1, .1])
 
1.0
 
 
 
math. gcd(a,b)
 
       返回整数a与b的最大公约数。如果a与b都为非零值，该函数的返回值是可以同时整除a与b的最大正整数。gcd(0, 0)的值为0。
 
 
 
math. isclose(a, b, *,rel_tol=1e-09, abs=0.0)
 
       如果a与b彼此相近的程度满足rel_tol（相对精度，按比例算，以a与b绝对值较大的为标准1）与abs_tol（绝对精度，按数值差算）规定的精度（那个容许的范围大，以哪个为评判标准），那么返回True；否则返回False。
 
 
 
math. isfinite(x)
 
       如果x不是无穷数或NaN，返回True。
 
 
 
math. isinf(x)
 
       如果x是正无穷或负无穷，返回True。
 
 
 
math. isnan(x)
 
       如果x是NaN，返回True。
 
 
 
math. ldexp(x, i)
 
       返回x*(2**i)的值。
 
 
 
math. modf(x)
 
       返回x的小数部分和整数部分。两个值都为浮点数格式，且带有x的符号。
 
 
 
math. trunc(x)
 
       将实数x截断为一个Integral格式的数（通常为整数格式）。
 
 
 
2.幂函数和对数函数
 
math. exp(x)
 
       返回e**x
 
 
 
math. expml(x)
 
       返回e**x – 1。该函数对小浮点数x提供了良好的精度参照。
 
 
 
math. log(x[, base])
 
       base若为给出，求以e为底的x的对数；base给出，则以base为底。
 
 
 
math. logl[(x)
 
       返回以e为底1+x的对数，该函数对于近似于0的x值有较高精度。
 
 
 
math. log2(x)
 
       返回以2为底的x的对数。
 
 
 
math. log10(x)
 
       返回以10为底x的对数。
 
 
 
math. pow(x, y)
 
       返回x**y的值。
 
 
 
math. sqrt(x)
 
       返回x的平方根。
 
 
 
3.三角函数
 
math. acos(x)
 
       返回x的反余弦值，以弧度形式，下面也相同。
 
 
 
math. asin(x)
 
       返回x的反正弦值。
 
 
 
math. atan(x)
 
       返回x的反正切值。
 
 
 
math. atan2(y, x)
 
       返回atan(y/x)，结果在[-pi,pi]之内。
 
 
 
math. cos(x)
 
       返回x弧度的余弦值。
 
 
 
math. hypot(x, y)
 
       返回点（x, y）到原点的距离。
 
 
 
math. sin(x)
 
       返回x弧度的正弦值。
 
 
 
math. tan(x)
 
       返回x弧度的正切值。
 
 
 
4.角度转换
 
math. degrees(x)
 
       将弧度值x转化为角度值。
 
 
 
math. radians(x)
 
       将角度值x转化为弧度值。
 
 
 
5. 双曲函数
 
       双曲函数是基于圆的三角函数在双曲线上的类比。
 
math. acosh(x)
 
       返回x的反双曲余弦值。
 
 
 
math. asinh(x)
 
       返回x的反双曲正弦值。
 
 
 
math. atanh(x)
 
       返回x的反双曲正切值。
 
 
 
math. cosh(x)
 
       返回x的双曲余弦值。
 
 
 
math. sinh(x)
 
       返回x的双曲正弦值。
 
 
 
math. tanh(x)
 
       返回x的双曲正切值。
 
 
 
6. 特殊函数
 
math. erf(x)
 
       返回x处的error函数。其可用于计算传统统计函数。
 
 
 
math. erfc(x)
 
       返回x处的补充错误函数.
 
 
 
math. gamma(x)
 
       返回x处的Gamma函数。
 
 
 
math. lgamma(x)
 
       返回x处Gamma函数绝对值的自然对数。
 
 
 
7. 常量
 
math. pi
 
       pi即为圆周率常量。
 
 
 
math. e
 
       e即为自然底数，e=2.718281…
 
 
 
math. tau
 
       数字常量T = 6.283185…
 
 
 
math. inf 
 
       浮点格式的正无穷。
 
 
 
math. nan
 
       浮点格式的非数字值。