Python内置模块-Math
文章目录
- Python内置模块-Math
-
- 一、模块介绍
- 二、数值运算
-
- 1.math.ceil()
- 2.math.floor()
- 3.math.fabs()
- 4.math.modf()
- 5.math.trunc()
- 6.math.factorial()
- 7.math.fmod()
- 8.math.fsum()
- 9.math.gcd()
- 10.math.frexp()
- 11.math.ldexp()
- 12.math.copysign()
- 13.math.isclose()
- 14.math.isfinite()
- 15.math.isinf()a
- 16.math.isnan
- 三、幂和对数运算
-
- 1.math.pow
- 2.math.exp
- 3.math.expm1
- 4.math.sqrt
- 5.math.log
- 6.math.log1p
- 7.math.log2
- 8.math.log10
- 四、三角函数
-
- 1.math.degrees
- 2.math.radians
- 3.math.hypot
- 4.math.sin
- 5.math.cos
- 6.math.tan
- 7.math.acos
- 8.math.asin
- 9.math.atan
- 10.math.atan2
- 五、双曲函数
-
- 1.math.sinh
- 2.math.cosh
- 3.math.tanh
- 4.math.asinh
- 5.math.acosh
- 6.math.atanh
- 7.math.erf
- 8.math.erfc
- 9.math.gamma
- 10.math.lgamma
- 六、常量
Python内置模块-Math
一、模块介绍
math模块是Python的内置模块，提供了许多对浮点数的数学运算函数。
二、数值运算
1.math.ceil()
作用
返回大于或等于指定数字的最小整数。
语法
math.ceil(x)
参数
x：数字，整数或浮点数
示例
import math
# 浮点数向上取整
print(math.ceil(1.4)) # 输出: 2
print(math.ceil(1.0)) # 输出: 1
print(math.ceil(-0.5)) # 输出: 0
# 整数向上取整
print(math.ceil(5)) # 输出: 5
print(math.ceil(-5)) # 输出: -5
2.math.floor()
作用
返回不大于给定数字的最大整数。
语法
math.floor(x)
参数
x：数字，整数或浮点数
示例
import math
# 对于正数，返回小于或等于该数的最大整数
print(math.floor(3.8)) # 输出: 3
# 对于负数，返回小于或等于该数的最大整数
print(math.floor(-2.3)) # 输出: -3
# 对于整数，返回相同的整数
print(math.floor(5)) # 输出: 5
# 对于零，返回零
print(math.floor(0.0)) # 输出: 0
3.math.fabs()
作用
返回数字的绝对值。
语法
math.fabs(x)
参数
x：数字，整数或浮点数
示例
import math
# 计算整数的绝对值
print(math.fabs(-5)) # 输出: 5
# 计算浮点数的绝对值
print(math.fabs(3.14159)) # 输出: 3.14159
# 计算负浮点数的绝对值
print(math.fabs(-2.71828)) # 输出: 2.71828
# 计算零的绝对值
print(math.fabs(0)) # 输出: 0.0
4.math.modf()
作用
将一个浮点数分解为整数部分和小数部分，返回一个元组，包含两个浮点数：第一个是小数部分，第二个是整数部分，整数部分是向零取整的结果，它不会四舍五入到最近的整数。
语法
math.modf(x)
参数
x：浮点数
示例
import math
# 正数
result = math.modf(12.3456)
print(result) # 输出: (0.34559999999999924, 12.0)
# 负数
result = math.modf(-12.3456)
print(result) # 输出: (-0.34559999999999924, -12.0)
# 零
result = math.modf(0.0)
print(result) # 输出: (0.0, 0.0)
# 整数
result = math.modf(5)
print(result) # 输出: (0.0, 5.0)
# 小数
result = math.modf(0.12345)
print(result) # 输出: (0.12345, 0.0)
5.math.trunc()
作用
返回一个数的整数部分，去除小数部分。这个函数对于正数和负数都适用，并且总是向0舍入。
语法
math.trunc(x)
参数
x：数值表达式，要去除小数部分的数
示例
import math
# 计算正数的整数部分
trunc_positive = math.trunc(10.9)
print(trunc_positive) # 输出: 10
# 计算负数的整数部分
trunc_negative = math.trunc(-10.9)
print(trunc_negative) # 输出: -10
# 计算零的整数部分
trunc_zero = math.trunc(0.0)
print(trunc_zero) # 输出: 0
# 计算整数的整数部分
trunc_integer = math.trunc(15)
print(trunc_integer) # 输出: 15
# 计算非常大的数的整数部分
trunc_large_number = math.trunc(12345678901234567890.9)
print(trunc_large_number) # 输出: 12345678901234567890
# 计算非常小的数的整数部分
trunc_small_number = math.trunc(0.0000000000000009)
print(trunc_small_number) # 输出: 0
6.math.factorial()
作用
计算给定非负整数的阶乘。阶乘表示的是从1乘到该数的所有正整数的乘积，用符号!表示，例如，5!表示5*4*3*2*1。
语法
math.factorial(x)
参数
x：非负整数，如果x是负数或者非整数，函数将抛出ValueError
示例
import math
# 计算数字 5 的阶乘
factorial_of_5 = math.factorial(5)
print(factorial_of_5) # 输出: 120
# 计算数字 0 的阶乘
factorial_of_0 = math.factorial(0)
print(factorial_of_0) # 输出: 1
# 尝试计算负数的阶乘（这将引发错误）
try:
factorial_of_negative = math.factorial(-1)
except ValueError as e:
print(e) # 输出: factorial() not defined for negative values
# 尝试计算非整数的阶乘（这将引发错误）
try:
factorial_of_non_integer = math.factorial(3.5)
except ValueError as e:
print(e) # 输出: factorial() only accepts integral values
7.math.fmod()
作用
计算两个数的浮点除法的余数，这个函数的行为类似于内置的%运算符，但是fmod总是返回带有与第二个参数(除数)相同符号的余数。
语法
math.fmod(x, y)
参数
x：被除数，可以是整数或浮点数y：除数，可以是整数或浮点数，但不能为零，如果y为零，将引发ValueError
示例
import math
# 计算正数的余数
remainder_positive = math.fmod(10, 3)
print(remainder_positive) # 输出: 1.0
# 计算负数的余数
remainder_negative = math.fmod(-10, 3)
print(remainder_negative) # 输出: -1.0
# 计算浮点数的余数
remainder_float = math.fmod(7.5, 2.5)
print(remainder_float) # 输出: 0.5
# 尝试除数为零的情况（这将引发错误）
try:
remainder_zero_divisor = math.fmod(10, 0)
except ValueError as e:
print(e) # 输出: math domain error
8.math.fsum()
作用
计算一系列数字的准确浮点数之和，这个函数比内置的sum函数更精确，因为fsum使用Kahan求和算法来减少浮点数求和时可能出现的精度损失。
语法
math.fsum(iterable)
参数
iterable：包含数字的可迭代对象，如列表、元组等
示例
import math
# 使用 fsum 计算一组浮点数的和
numbers = [0.1, 0.2, 0.3, 0.4, 0.5]
sum_fsum = math.fsum(numbers)
print(sum_fsum) # 输出: 1.5
# 比较内置 sum 和 math.fsum 的结果
sum_builtin = sum(numbers)
print(sum_builtin) # 输出可能不是精确的 1.5，例如 1.5000000000000002
# 使用 fsum 计算范围中的数字和
sum_range = math.fsum(range(1, 101))
print(sum_range) # 输出: 5050
# 使用 fsum 计算包含非常大的数字和非常小的数字的列表
big_small_numbers = [1e100, 1e-100, -1e100, 1e-100]
sum_big_small = math.fsum(big_small_numbers)
print(sum_big_small) # 输出: 0.0
9.math.gcd()
作用
计算两个整数的最大公约数(Greatest Common Divisor)。
语法
math.gcd(a, b)
参数
a：第一个整数b：第二个整数
示例
import math
# 计算两个正整数的最大公约数
print(math.gcd(54, 24)) # 输出: 6
# 计算包含0的情况
print(math.gcd(0, 5)) # 输出: 5
print(math.gcd(5, 0)) # 输出: 5
print(math.gcd(0, 0)) # 输出: 0
# 计算负整数的最大公约数（结果总是非负的）
print(math.gcd(-54, 24)) # 输出: 6
print(math.gcd(54, -24)) # 输出: 6
print(math.gcd(-54, -24)) # 输出: 6
# 计算两个相同整数的最大公约数
print(math.gcd(100, 100)) # 输出: 100
# 计算互质数的最大公约数
print(math.gcd(7, 11)) # 输出: 1
10.math.frexp()
作用
将浮点数分解为尾数(significand或mantissa)和指数。
语法
math.frexp(x)
参数
x：浮点数
示例
import math
# 分解浮点数
significand, exponent = math.frexp(12.3456)
print("尾数:", significand) # 输出尾数 0.7716
print("指数:", exponent) # 输出指数 4
# 分解浮点数 0
significand, exponent = math.frexp(0.0)
print("尾数:", significand) # 输出尾数 0.0
print("指数:", exponent) # 输出指数 0
# 分解浮点数 -12.3456
significand, exponent = math.frexp(-12.3456)
print("尾数:", significand) # 输出尾数 -0.7716
print("指数:", exponent) # 输出指数 4
11.math.ldexp()
作用
将一个尾数(significand或mantissa)和一个指数结合成一个浮点数，这个函数是frexp函数的逆操作，用于重建由frexp分解的浮点数。
语法
math.ldexp(significand, exponent)
参数
significand：尾数，通常是一个浮点数，其绝对值应该位于区间[0.5, 1)内exponent：指数，一个整数
示例
import math
# 示例 1: 使用 frexp 和 ldexp
original_number = 12.3456
significand, exponent = math.frexp(original_number)
reconstructed_number = math.ldexp(significand, exponent)
print("原始数字:", original_number) # 输出 12.3456
print("重建数字:", reconstructed_number) # 输出 12.3456
# 示例 2: 直接使用 ldexp
significand = 0.9552734375 # 从示例 1 的 frexp 输出中获得
exponent = 4 # 从示例 1 的 frexp 输出中获得
result = math.ldexp(significand, exponent)
print("重建数字:", result) # 输出 15.284375
12.math.copysign()
作用
将第二个浮点数的符号(正或负)复制给第一个浮点数，并返回结果。
语法
math.copysign(x, y)
参数
x：浮点数，其符号将被替换y：浮点数，其符号将被复制
示例
import math
# 示例 1: 将正数的符号复制给负数
x = -5.0
y = 3.0
result = math.copysign(x, y)
print("Result:", result) # 输出: Result: 5.0
# 示例 2: 将负数的符号复制给正数
x = 5.0
y = -3.0
result = math.copysign(x, y)
print("Result:", result) # 输出: Result: -5.0
# 示例 3: 两个正数
x = 5.0
y = 3.0
result = math.copysign(x, y)
print("Result:", result) # 输出: Result: 5.0
# 示例 4: 两个负数
x = -5.0
y = -3.0
result = math.copysign(x, y)
print("Result:", result) # 输出: Result: -5.0
13.math.isclose()
作用
比较两个值是否在一定的误差范围内相等。这对于浮点数比较特别有用，因为直接比较浮点数可能会由于精度问题导致不正确的结果。
语法
math.isclose(a, b, *, rel_tol=1e-09, abs_tol=0.0)
参数
a：第一个比较的数b：第二个比较的数rel_tol：相对容差，默认为1e-09，相对容差是相对于输入值的大小的一个容差量，表示为b的绝对值与a的绝对值之比abs_tol：绝对容差，默认为0.0，绝对容差是独立于输入值大小的容差量
示例
import math
# 示例 1: 默认容差比较
a = 0.1 + 0.2
b = 0.3
print(a == b) # 输出: False
print(math.isclose(a, b)) # 输出: True
# 示例 2: 使用自定义相对容差
a = 1.000001
b = 1.000002
print(math.isclose(a, b, rel_tol=1e-6)) # 输出: True
print(math.isclose(a, b, rel_tol=1e-7)) # 输出: False
# 示例 3: 使用自定义绝对容差
a = 1e-10
b = 2e-10
print(math.isclose(a, b, abs_tol=1e-9)) # 输出: True
print(math.isclose(a, b, abs_tol=1e-11)) # 输出: False
# 示例 4: 相对容差和绝对容差同时使用
a = 1e-10
b = 1.000001e-10
print(math.isclose(a, b, rel_tol=1e-5, abs_tol=1e-9)) # 输出: True
14.math.isfinite()
作用
检查给定值是否是有限的，即不是无穷大(infinity)也不是非数(NaN，Not a Number)，对于整数和浮点数，这个函数可以确定它们是否在有限的范围内。
语法
math.isfinite(x)
参数
x：要检查的数，整数或浮点数
示例
import math
# 检查正整数
print(math.isfinite(10)) # 输出: True
# 检查负整数
print(math.isfinite(-10)) # 输出: True
# 检查浮点数
print(math.isfinite(3.14)) # 输出: True
# 检查无穷大
print(math.isfinite(math.inf)) # 输出: False
print(math.isfinite(float('inf'))) # 输出: False
# 检查负无穷大
print(math.isfinite(-math.inf)) # 输出: False
print(math.isfinite(float('-inf'))) # 输出: False
# 检查 NaN
print(math.isfinite(math.nan)) # 输出: False
print(math.isfinite(float('nan'))) # 输出: False
# 检查 0
print(math.isfinite(0)) # 输出: True
print(math.isfinite(-0.0)) # 输出: True
15.math.isinf()a
作用
检查一个数是否是正无穷大或负无穷大。
语法
math.isinf(x)
参数
x：要检查的数，整数或浮点数
示例
import math
# 检查正整数
print(math.isinf(10)) # 输出: False
# 检查负整数
print(math.isinf(-10)) # 输出: False
# 检查浮点数
print(math.isinf(3.14)) # 输出: False
# 检查正无穷大
print(math.isinf(math.inf)) # 输出: True
print(math.isinf(float('inf'))) # 输出: True
# 检查负无穷大
print(math.isinf(-math.inf)) # 输出: True
print(math.isinf(float('-inf'))) # 输出: True
# 检查 NaN（非数）
print(math.isinf(math.nan)) # 输出: False
print(math.isinf(float('nan'))) # 输出: False
# 检查 0
print(math.isinf(0)) # 输出: False
print(math.isinf(-0.0)) # 输出: False
16.math.isnan
作用
检查一个数是否是NaN(Not a Number)，即非数。
语法
math.isnan(x)
参数
x：要检查的数，整数或浮点数
示例
import math
# 检查正整数
print(math.isnan(10)) # 输出: False
# 检查负整数
print(math.isnan(-10)) # 输出: False
# 检查浮点数
print(math.isnan(3.14)) # 输出: False
# 检查 NaN
print(math.isnan(math.nan)) # 输出: True
print(math.isnan(float('nan'))) # 输出: True
# 检查无穷大
print(math.isnan(math.inf)) # 输出: False
print(math.isnan(-math.inf)) # 输出: False
# 检查 0
print(math.isnan(0)) # 输出: False
print(math.isnan(-0.0)) # 输出: False
三、幂和对数运算
1.math.pow
作用
计算x的y次幂，即 x y x^y xy，它返回x的y次幂的值。
语法
math.pow(x, y)
参数
x：底数，任意数值类型y：指数，任意数值类型
示例
import math
# 计算正数的幂
print(math.pow(2, 3)) # 输出: 8.0
# 计算负数的幂
print(math.pow(-2, 3)) # 输出: -8.0
# 计算分数的幂
print(math.pow(2, -3)) # 输出: 0.125
# 计算浮点数的幂
print(math.pow(2.5, 2)) # 输出: 6.25
# 计算指数为 0 的情况
print(math.pow(7, 0)) # 输出: 1.0
# 计算底数为 0 的情况
print(math.pow(0, 3)) # 输出: 0.0
# 注意：以下情况将引发 ValueError
# 因为 -2 是负数，而 0.5 不是整数
# print(math.pow(-2, 0.5))
2.math.exp
作用
返回e(自然对数的底数)的x次方。
语法
math.exp(x)
参数
x：数字，整数或浮点数，表示e的指数
示例
import math
# 计算 e 的次方
print(math.exp(1)) # 输出: 2.718281828459045
print(math.exp(0)) # 输出: 1.0
print(math.exp(-1)) # 输出: 0.36787944117144233
# 使用浮点数
print(math.exp(2.3)) # 输出: 9.974182454814034
# 使用较大的负数
print(math.exp(-5)) # 输出: 0.006737946999085467
3.math.expm1
作用
计算e的x次幂减1的值，即 e x − 1 e^x-1 ex−1，expm1函数在数值计算中很有用，因为它能够减少在x接近0时由于浮点数的精度限制而产生的误差。
语法
math.expm1(x)
参数
x：数值表达式，表示e的指数
示例
import math
# 计算 e^0 - 1
print(math.expm1(0)) # 输出: 0.0
# 计算 e^1 - 1
print(math.expm1(1)) # 输出: 1.718281828459045
# 计算 e^2 - 1
print(math.expm1(2)) # 输出: 6.38905609893065
# 计算 e^-1 - 1
print(math.expm1(-1)) # 输出: -0.6321205588285577
# 计算 e^0.01 - 1
print(math.expm1(0.01)) # 输出: 0.010050167084164242
# 计算 e^-0.01 - 1
print(math.expm1(-0.01)) # 输出: -0.009950166589930842
4.math.sqrt
作用
计算一个数的平方根，它返回非负数的平方根。
语法
math.sqrt(x)
参数
x：非负数(大于等于0)，即需要计算平方根的数
示例
import math
# 计算正数的平方根
print(math.sqrt(16)) # 输出: 4.0
# 计算浮点数的平方根
print(math.sqrt(2.25)) # 输出: 1.5
# 计算 0 的平方根
print(math.sqrt(0)) # 输出: 0.0
# 注意：以下情况将引发 ValueError
# 因为 -4 是负数，没有实数平方根
# print(math.sqrt(-4))
5.math.log
作用
计算自然对数(即以e为底的对数)。
语法
math.log(x, [base])
参数
x：正数，需要计算其自然对数的数base：对数的底数。如果省略，则默认计算自然对数(底数为e)
示例
import math
# 计算自然对数（底数为 e）
print(math.log(math.e)) # 输出: 1.0
print(math.log(1)) # 输出: 0.0
# 计算以 10 为底的对数
print(math.log(100, 10)) # 输出: 2.0
# 计算以 2 为底的对数
print(math.log(8, 2)) # 输出: 3.0
# 如果 x 是负数或零，math.log 会抛出 ValueError
try:
print(math.log(-1))
except ValueError as e:
print(e) # 输出: math domain error
try:
print(math.log(0))
except ValueError as e:
print(e) # 输出: math domain error
6.math.log1p
作用
计算1+x的自然对数(底数为e的对数)，这个函数是为了在x非常接近0时提供更高的精度，因为在x接近0时，直接计算math.log(1 + x)可能会因为浮点数的精度问题而损失精度。
语法
math.log1p(x)
参数
x：数值，通常是接近0的正数，表示要计算1 + x的自然对数
示例
import math
# 计算 1 + 0 的自然对数
print(math.log1p(0)) # 输出: 0.0
# 计算 1 + 0.000001 的自然对数
# 使用 math.log1p 以获得更高的精度
print(math.log1p(0.000001)) # 输出: 1.0000000005000001e-06
# 计算 1 + 0.1 的自然对数
print(math.log1p(0.1)) # 输出: 0.09531017980432493
# 计算 1 + 1 的自然对数
print(math.log1p(1)) # 输出: 0.6931471805599453
# 计算 1 + 10 的自然对数
print(math.log1p(10)) # 输出: 2.3978952727983707
# 计算 1 + 100 的自然对数
print(math.log1p(100)) # 输出: 4.605170185988092
# 计算 1 + -0.000001 的自然对数
# 注意：x 不能是负数，因为 log1p(1 + x) 在 x 为负数时是未定义的
# 下面的代码将抛出 ValueError
try:
print(math.log1p(-0.000001))
except ValueError as e:
print("ValueError:", e) # 输出: ValueError: math domain error
7.math.log2
作用
计算以2为底的对数。
语法
math.log2(x)
参数
x：大于0的数值，表示要计算其以2为底的对数
示例
import math
# 计算 1 的以 2 为底的对数
print(math.log2(1)) # 输出: 0.0
# 计算 2 的以 2 为底的对数
print(math.log2(2)) # 输出: 1.0
# 计算 4 的以 2 为底的对数
print(math.log2(4)) # 输出: 2.0
# 计算 8 的以 2 为底的对数
print(math.log2(8)) # 输出: 3.0
# 计算 16 的以 2 为底的对数
print(math.log2(16)) # 输出: 4.0
# 计算 0.5 的以 2 为底的对数
print(math.log2(0.5)) # 输出: -1.0
# 计算 10 的以 2 为底的对数
print(math.log2(10)) # 输出: 3.3219280948873626
# 计算 32 的以 2 为底的对数
print(math.log2(32)) # 输出: 5.0
# 尝试计算负数或零的对数将抛出 ValueError
try:
print(math.log2(-1))
except ValueError as e:
print("ValueError:", e) # 输出: ValueError: math domain error
try:
print(math.log2(0))
except ValueError as e:
print("ValueError:", e) # 输出: ValueError: math domain error
8.math.log10
作用
计算一个数的以10为底的对数。
语法
math.log10(x)
参数
x：正数，要计算其以10为底的对数的数
示例
import math
# 计算以 10 为底的对数
print(math.log10(1)) # 输出: 0.0
print(math.log10(10)) # 输出: 1.0
print(math.log10(100)) # 输出: 2.0
print(math.log10(1000)) # 输出: 3.0
# 如果 x 是负数或零，math.log10 会抛出 ValueError
try:
print(math.log10(-1))
except ValueError as e:
print(e) # 输出: math domain error
try:
print(math.log10(0))
except ValueError as e:
print(e) # 输出: math domain error
四、三角函数
1.math.degrees
作用
将弧度转换为度。
语法
math.degrees(x)
参数
x：数值表达式，需要转换的弧度值
示例
import math
# 将π弧度转换为度
print(math.degrees(math.pi)) # 输出: 180.0
# 将π/2弧度转换为度
print(math.degrees(math.pi / 2)) # 输出: 90.0
# 将2π弧度转换为度
print(math.degrees(2 * math.pi)) # 输出: 360.0
# 将一个随机弧度值转换为度
random_radians = 1.0471975511965979 # 这实际上是60度对应的弧度值
print(math.degrees(random_radians)) # 输出: 60.0
2.math.radians
作用
将角度转换为弧度。
语法
math.radians(x)
参数
x：数值表达式，需要转换的度数值
示例
import math
# 将180度转换为弧度
print(math.radians(180)) # 输出: 3.141592653589793
# 将90度转换为弧度
print(math.radians(90)) # 输出: 1.5707963267948966
# 将360度转换为弧度
print(math.radians(360)) # 输出: 6.283185307179586
# 将一个随机度数值转换为弧度
random_degrees = 60 # 60度
print(math.radians(random_degrees)) # 输出: 1.0471975511965976
3.math.hypot
作用
计算直角三角形的斜边长度，即计算两个数的平方和的平方根。
语法
math.hypot(x,y)
参数
x：数值表达式，直角三角形的第一个直角边的长度y：数值表达式，直角三角形的第二个直角边的长度
示例
import math
# 计算直角三角形斜边长度，其中两个直角边长度分别为3和4
print(math.hypot(3, 4)) # 输出: 5.0
# 计算直角三角形斜边长度，其中两个直角边长度分别为5和12
print(math.hypot(5, 12)) # 输出: 13.0
# 计算直角三角形斜边长度，其中两个直角边长度分别为8和15
print(math.hypot(8, 15)) # 输出: 17.0
# 计算直角三角形斜边长度，其中两个直角边长度分别为-3和-4
# hypot函数可以处理负数，它返回的是正数的斜边长度
print(math.hypot(-3, -4)) # 输出: 5.0
# 计算直角三角形斜边长度，其中两个直角边长度分别为0和0
# 0和0的斜边长度是0
print(math.hypot(0, 0)) # 输出: 0.0
4.math.sin
作用
计算一个数的正弦值，它接受一个弧度值作为参数，并返回该角度的正弦值。
语法
math.sin(x)
参数
x：数值，表示需要计算正弦的弧度
示例
import math
# 计算弧度 0 的正弦值
print(math.sin(0)) # 输出: 0.0
# 计算弧度 π/2 的正弦值
print(math.sin(math.pi / 2)) # 输出: 1.0
# 计算弧度 π 的正弦值
print(math.sin(math.pi)) # 输出: 1.2246467991473532e-16 (接近于 0)
# 计算弧度 3π/2 的正弦值
print(math.sin(3 * math.pi / 2)) # 输出: -1.0
# 计算弧度 -π/2 的正弦值
print(math.sin(-math.pi / 2)) # 输出: -1.0
# 计算弧度 -π 的正弦值
print(math.sin(-math.pi)) # 输出: -2.4492935982947064e-16 (接近于 0)
# 计算弧度 -3π/2 的正弦值
print(math.sin(-3 * math.pi / 2)) # 输出: 1.0
# 计算弧度 45 度（先将度转换为弧度）
print(math.sin(math.radians(45))) # 输出: 0.7071067811865475
5.math.cos
作用
计算角度(以弧度为单位)的余弦值。
语法
math.cos(x)
参数
x：数值表达式，以弧度为单位的角度
示例
import math
# 计算π/4弧度的余弦值
print(math.cos(math.pi / 4)) # 输出: 0.7071067811865475
# 计算π/2弧度的余弦值
print(math.cos(math.pi / 2)) # 输出: 6.123233995736766e-17 (接近于0)
# 计算π弧度的余弦值
print(math.cos(math.pi)) # 输出: -1.0
# 计算0弧度的余弦值
print(math.cos(0)) # 输出: 1.0
# 计算负π/3弧度的余弦值
print(math.cos(-math.pi / 3)) # 输出: 0.5
# 注意：math.cos函数要求输入的是弧度，而不是度。
# 如果你有一个角度的度数，你需要先将它转换为弧度。
# 以下是将度转换为弧度的示例：
degrees = 45
radians = math.radians(degrees)
print(math.cos(radians)) # 输出: 0.7071067811865475
6.math.tan
作用
计算一个数的正切值，它接受一个弧度值作为参数，并返回该角度的正切值。
语法
math.tan(x)
参数
x：数值，表示需要计算正切的弧度
示例
import math
# 计算弧度 0 的正切值
print(math.tan(0)) # 输出: 0.0
# 计算弧度 π/4 的正切值
print(math.tan(math.pi / 4)) # 输出: 1.0
# 计算弧度 π/3 的正切值
print(math.tan(math.pi / 3)) # 输出: 1.7320508075688767
# 计算弧度 π/2 的正切值
# 注意：π/2 的正切值是无穷大
print(math.tan(math.pi / 2)) # 输出: inf (无穷大)
# 计算弧度 π 的正切值
print(math.tan(math.pi)) # 输出: 0.0
# 计算弧度 3π/4 的正切值
print(math.tan(3 * math.pi / 4)) # 输出: -1.0
# 计算弧度 -π/4 的正切值
print(math.tan(-math.pi / 4)) # 输出: -1.0
# 计算弧度 -π/3 的正切值
print(math.tan(-math.pi / 3)) # 输出: -1.7320508075688767
# 计算弧度 -π/2 的正切值
# 注意：-π/2 的正切值是负无穷大
print(math.tan(-math.pi / 2)) # 输出: -inf (负无穷大)
# 计算弧度 -π 的正切值
print(math.tan(-math.pi)) # 输出: 0.0
# 计算弧度 -3π/4 的正切值
print(math.tan(-3 * math.pi / 4)) # 输出: 1.0
# 计算弧度 45 度（先将度转换为弧度）
print(math.tan(math.radians(45))) # 输出: 1.0
7.math.acos
作用
计算一个数的反余弦值(arcosine)，它返回的角度范围是[0, π]弧度。
语法
math.acos(x)
参数
x：数值，需要计算反余弦的数，必须在[-1, 1]范围内，超出这个范围会引发ValueError
示例
import math
# 计算数值 1 的反余弦值
print(math.acos(1)) # 输出: 0.0
# 计算数值 -1 的反余弦值
print(math.acos(-1)) # 输出: 3.141592653589793
# 计算数值 0.5 的反余弦值
print(math.acos(0.5)) # 输出: 1.0471975511965979
# 计算数值 -0.5 的反余弦值
print(math.acos(-0.5)) # 输出: 2.0943951023931957
# 注意：以下情况将引发 ValueError
# 因为 1.5 超出了 [-1, 1] 的范围
# print(math.acos(1.5))
8.math.asin
作用
计算一个数的反正弦值(arcsine)，它返回的角度范围是[-π/2, π/2]弧度。
语法
math.asin(x)
参数
x：数值，需要计算反正弦的数，必须在[-1, 1]范围内，超出这个范围会引发ValueError
示例
import math
# 计算数值 0 的反正弦值
print(math.asin(0)) # 输出: 0.0
# 计算数值 1 的反正弦值
print(math.asin(1)) # 输出: 1.5707963267948966 (π/2)
# 计算数值 -1 的反正弦值
print(math.asin(-1)) # 输出: -1.5707963267948966 (-π/2)
# 计算数值 0.5 的反正弦值
print(math.asin(0.5)) # 输出: 0.5235987755982989
# 计算数值 -0.5 的反正弦值
print(math.asin(-0.5)) # 输出: -0.5235987755982989
# 注意：以下情况将引发 ValueError
# 因为 1.5 超出了 [-1, 1] 的范围
# print(math.asin(1.5))
9.math.atan
作用
计算一个数的反正切值(arctangent)，它返回的角度范围是[-π/2, π/2]弧度。
语法
math.atan(x)
参数
x：数值，表示需要计算反正切的数
示例
import math
# 计算数值 0 的反正切值
print(math.atan(0)) # 输出: 0.0
# 计算数值 1 的反正切值
print(math.atan(1)) # 输出: 0.7853981633974483 (π/4)
# 计算数值 -1 的反正切值
print(math.atan(-1)) # 输出: -0.7853981633974483 (-π/4)
# 计算数值 0.5 的反正切值
print(math.atan(0.5)) # 输出: 0.4636476090008061
# 计算数值 -0.5 的反正切值
print(math.atan(-0.5)) # 输出: -0.4636476090008061
# 计算数值无穷大的反正切值
print(math.atan(float('inf'))) # 输出: 1.5707963267948966 (π/2)
# 计算数值负无穷大的反正切值
print(math.atan(float('-inf'))) # 输出: -1.5707963267948966 (-π/2)
10.math.atan2
作用
计算给定的X和Y坐标值的反正切(角度)，其返回值是介于-π到π之间的角度(以弧度为单位)，这个函数与atan函数不同，它可以确定角度所在的象限。
语法
math.atan2(y, x)
参数
y：数值表达式，表示Y坐标或对边长度x：数值表达式，表示X坐标或邻边长度
示例
import math
# 计算点(1, 1)的角度
angle = math.atan2(1, 1)
print(angle) # 输出: 0.7853981633974483 (π/4弧度)
# 计算点(0, 1)的角度
angle = math.atan2(1, 0)
print(angle) # 输出: 1.5707963267948966 (π/2弧度)
# 计算点(-1, 0)的角度
angle = math.atan2(-1, 0)
print(angle) # 输出: -1.5707963267948966 (-π/2弧度)
# 计算点(-1, -1)的角度
angle = math.atan2(-1, -1)
print(angle) # 输出: -2.356194490192345 (-3π/4弧度)
# 计算点(0, -1)的角度
angle = math.atan2(-1, 0)
print(angle) # 输出: -1.5707963267948966 (-π/2弧度)
# 计算点(1, -1)的角度
angle = math.atan2(-1, 1)
print(angle) # 输出: -0.7853981633974483 (-π/4弧度)
五、双曲函数
1.math.sinh
作用
计算双曲正弦值，双曲正弦是对数函数的自然对数形式。
语法
math.sinh(x)
参数
x：数值表达式，要计算其双曲正弦的数值
示例
import math
# 计算双曲正弦值
sinh_positive = math.sinh(1)
print(sinh_positive) # 输出: 1.1752011936438014
sinh_negative = math.sinh(-1)
print(sinh_negative) # 输出: -1.1752011936438014
sinh_zero = math.sinh(0)
print(sinh_zero) # 输出: 0.0
# 计算一些较大的数值的双曲正弦
sinh_large = math.sinh(10)
print(sinh_large) # 输出: 11013.232874703393
# 计算一些较小的数值的双曲正弦
sinh_small = math.sinh(0.01)
print(sinh_small) # 输出: 0.010050167084168055
2.math.cosh
作用
计算双曲余弦值。双曲余弦是对数函数的自然对数形式。
语法
math.cosh(x)
参数
x：数值表达式，要计算其双曲余弦的数值
示例
import math
# 计算双曲余弦值
cosh_positive = math.cosh(1)
print(cosh_positive) # 输出: 1.5430806348152437
cosh_negative = math.cosh(-1)
print(cosh_negative) # 输出: 1.5430806348152437
cosh_zero = math.cosh(0)
print(cosh_zero) # 输出: 1.0
# 计算一些较大的数值的双曲余弦
cosh_large = math.cosh(10)
print(cosh_large) # 输出: 11013.232874703393
# 计算一些较小的数值的双曲余弦
cosh_small = math.cosh(0.01)
print(cosh_small) # 输出: 1.010050167084168
3.math.tanh
作用
计算双曲正切值，双曲正切是对数函数的自然对数形式。
语法
math.tanh(x)
参数
x：数值表达式，计算其双曲正切的数值
示例
import math
# 计算双曲正切值
tanh_positive = math.tanh(1)
print(tanh_positive) # 输出: 0.7615941559557649
tanh_negative = math.tanh(-1)
print(tanh_negative) # 输出: -0.7615941559557649
tanh_zero = math.tanh(0)
print(tanh_zero) # 输出: 0.0
# 计算一些较大的数值的双曲正切
tanh_large = math.tanh(10)
print(tanh_large) # 输出: 0.9999999958776927 (接近于 1)
# 计算一些较小的数值的双曲正切
tanh_small = math.tanh(0.01)
print(tanh_small) # 输出: 0.010000333353732692
4.math.asinh
作用
计算参数的反双曲正弦值(也称为逆双曲正弦或反双曲正弦函数)，反双曲正弦函数是双曲正弦函数的反函数。
语法
math.asinh(x)
参数
x：数值表达式，要计算其反双曲正弦的数值
示例
import math
# 计算反双曲正弦值
asinh_positive = math.asinh(1)
print(asinh_positive) # 输出: 0.881373587019543
asinh_negative = math.asinh(-1)
print(asinh_negative) # 输出: -0.881373587019543
asinh_zero = math.asinh(0)
print(asinh_zero) # 输出: 0.0
# 计算一些较大的数值的反双曲正弦
asinh_large = math.asinh(10)
print(asinh_large) # 输出: 2.99822295029797
# 计算一些较小的数值的反双曲正弦
asinh_small = math.asinh(0.01)
print(asinh_small) # 输出: 0.010000000000000002
5.math.acosh
作用
计算参数的反双曲余弦值(也称为逆双曲余弦或反双曲余弦函数)，反双曲余弦函数是双曲余弦函数的反函数。
语法
math.acosh(x)
参数
x：数值表达式，要计算其反双曲余弦的数值。该值必须大于等于1，因为双曲余弦函数的值域是[1, +∞)
示例
import math
# 计算反双曲余弦值
acosh_one = math.acosh(1)
print(acosh_one) # 输出: 0.0
acosh_two = math.acosh(2)
print(acosh_two) # 输出: 1.3169578969248166
# 尝试计算小于 1 的值的反双曲余弦将引发 ValueError
try:
acosh_negative = math.acosh(0.5)
except ValueError as e:
print(e) # 输出: math domain error
# 计算一些较大的数值的反双曲余弦
acosh_large = math.acosh(10)
print(acosh_large) # 输出: 2.993222846126381
# 计算一些接近 1 的数值的反双曲余弦
acosh_close_to_one = math.acosh(1.0001)
print(acosh_close_to_one) # 输出: 5.786744313905478e-05
6.math.atanh
作用
计算参数的反双曲正切值(也称为逆双曲正切或反双曲正切函数)，反双曲正切函数是双曲正切函数的反函数。
语法
math.atanh(x)
参数
x：数值表达式，要计算其反双曲正切的数值。该值必须在区间(-1, 1)内(不包括-1和1)，因为双曲正切函数的定义域是(-1, 1)
示例
import math
# 计算反双曲正切值
atanh_zero = math.atanh(0)
print(atanh_zero) # 输出: 0.0
atanh_half = math.atanh(0.5)
print(atanh_half) # 输出: 0.5493061443340548
# 尝试计算等于 -1 或 1 的值的反双曲正切将引发 ValueError
try:
atanh_one = math.atanh(1)
except ValueError as e:
print(e) # 输出: math domain error
try:
atanh_minus_one = math.atanh(-1)
except ValueError as e:
print(e) # 输出: math domain error
# 尝试计算区间外数值的反双曲正切将引发 ValueError
try:
atanh_two = math.atanh(2)
except ValueError as e:
print(e) # 输出: math domain error
# 计算一些接近 -1 和 1 的数值的反双曲正切
atanh_close_to_one = math.atanh(0.999999)
print(atanh_close_to_one) # 输出: 7.254328619247669
atanh_close_to_minus_one = math.atanh(-0.999999)
print(atanh_close_to_minus_one) # 输出: -7.254328619247669
7.math.erf
作用
计算高斯误差函数(Error)，数学表示： 2 π ∫ 0 x e − t 2 d t \frac{2}{\sqrt \pi}\int^x_0 e^{-t^2}dt π2∫0xe−t2dt。
语法
math.erf(x)
参数
x：实数，需要计算误差函数的值的位置
示例
import math
# 示例 1: 计算标准正态分布的误差函数值
x = 0.5
print(math.erf(x)) # 输出: 0.5204998778130465
# 示例 2: 计算负数的误差函数值
x = -0.5
print(math.erf(x)) # 输出: -0.5204998778130465
# 示例 3: 计算误差函数的极限值
# 当 x 趋向于正无穷时，erf(x) 趋向于 1
print(math.erf(float('inf'))) # 输出: 1.0
# 当 x 趋向于负无穷时，erf(x) 趋向于 -1
print(math.erf(float('-inf'))) # 输出: -1.0
# 当 x 为 0 时，erf(x) 为 0
print(math.erf(0)) # 输出: 0.0
8.math.erfc
参数
计算高斯互补误差函数(Complementary Error)，它是1减去误差函数erf(x)的值，数学表示： 2 π ∫ x ∞ e − t 2 d t \frac{2}{\sqrt \pi}\int^\infty_x e^{-t^2}dt π2∫x∞e−t2dt。
语法
math.erfc(x)
参数
x：实数，需要计算互补误差函数的值的位置
示例
import math
# 示例 1: 计算标准正态分布的互补误差函数值
x = 0.5
print(math.erfc(x)) # 输出: 0.4795001221869534
# 示例 2: 计算负数的互补误差函数值
x = -0.5
print(math.erfc(x)) # 输出: 1.5204998778130465
# 示例 3: 计算互补误差函数的极限值
# 当 x 趋向于正无穷时，erfc(x) 趋向于 0
print(math.erfc(float('inf'))) # 输出: 0.0
# 当 x 趋向于负无穷时，erfc(x) 趋向于 2
print(math.erfc(float('-inf'))) # 输出: 2.0
# 当 x 为 0 时，erfc(x) 为 1
print(math.erfc(0)) # 输出: 1.0
9.math.gamma
作用
计算伽玛函数(Gamma)，它是一个扩展到实数和复数域上的阶乘函数，通常表示为 Γ ( x ) \Gamma(x) Γ(x)，数学表示： ∫ 0 ∞ x t − 1 e − x d x \int^\infty_0 x^{t-1}e^{-x}dx ∫0∞xt−1e−xdx。
语法
math.gamma(x)
参数
x：实数，需要计算伽玛函数的值的点
示例
import math
# 计算不同数值的伽玛函数值
print(math.gamma(1)) # 输出: 1.0 (伽玛函数的特殊值，gamma(n) = (n-1)! 对于 n 是正整数)
print(math.gamma(0.5)) # 输出: 1.772453850905516 (伽玛函数的特殊值)
print(math.gamma(5.5)) # 输出: 52.34277778455352
# 尝试计算非正整数的伽玛函数值将引发 ValueError
# 下面的代码将引发异常
# print(math.gamma(-1)) # ValueError: math domain error
10.math.lgamma
作用
计算参数x的伽玛函数的对数值，与gamma函数相比，lgamma可以避免在x非常大时出现的数值溢出问题，并且可以直接处理负数参数，数学表示：ln(gamma(x))。
语法
math.lgamma(x)
参数
x: 浮点数，表示要计算其伽玛函数对数值的数值，x可以是任意实数，但通常使用正数
示例
import math
# 计算不同数值的伽玛函数对数值
print(math.lgamma(1)) # 输出: 0.0 (伽玛函数的特殊值，lgamma(n) = 0 对于 n 是正整数)
print(math.lgamma(0.5)) # 输出: 0.572365234479919 (伽玛函数的特殊值)
print(math.lgamma(5.5)) # 输出: 3.957813967618716
六、常量
math.pi：圆周率πmath.e：自然对数的底数emath.tau：圆周率的两倍，即2πmath.inf：正无穷大math.nan：NaN(不是数字)