Python 内置支持存储和处理数值数据（Python Numbers）。大多数时候，你会在几乎每一个 Python 应用程序中处理数字。显然，任何计算机应用程序都会处理数字。本教程将会讨论 Python 数字的不同类型及其属性。
Python 数字类型
Python 中有三种内置的数字类型：
-
-
-
复数 Python 还有一个内置的布尔数据类型叫做
bool。它可以被视为 int 类型的一个子类型，因为它只有两个可能的值 True 和 False，分别代表整数 1 和 0。
Python - 整数
在 Python 中，任何没有提供存储小数部分能力的数字都是整数。（注意，如果一个数字的小数部分为 0，并不意味着它是一个整数。例如，数字 10.0 不是一个整数，它是一个小数部分为 0 的浮点数，其数值为 10。）整数可以是零、正数或负数。例如，1234，0，-55 都代表 Python 中的整数。
形成整数对象有三种方法：(a) 字面量表示，(b) 任何评估为整数的表达式，以及 (c) 使用 int() 函数。
字面量是一种在源代码中直接用来表示常量的记号。例如：
>>> a = 10
然而，请看下面整数变量 c 的赋值。
a = 10
b = 20
c = a + b
print("a:", a, "type:", type(a))
print("c:", c, "type:", type(c))
它会产生以下输出：
a: 10 type: <class 'int'>
c: 30 type: <class 'int'>
在这里，c 确实是一个整数变量，但是表达式 a + b 先被评估，然后其值间接地赋给了 c。
形成整数对象的第三种方法是通过 int() 函数的返回值。它可以把一个浮点数或字符串转换成整数。
>>> a = int(10.5)
>>> b = int("100")
你可以用二进制、八进制或十六进制来表示一个整数。但是，内部对象还是存储为整数。
Python 中的二进制数
一个仅由二进制位（1 和 0）组成并且以 "0b" 开头的数字是一个二进制数。如果你把一个二进制数赋给一个变量，它仍然是一个 int 变量。
要表示一个二进制形式的整数，可以直接存储为字面量，或者使用 int() 函数，其中基数设为 2。
a = 0b101
print("a:", a, "type:", type(a))
b = int("0b101011", 2)
print("b:", b, "type:", type(b))
它会产生以下输出：
a: 5 type: <class 'int'>
b: 43 type: <class 'int'>
Python 中还有一个 bin() 函数。它返回一个整数的等价二进制字符串。
a = 43
b = bin(a)
print("Integer:", a, "Binary equivalent:", b)
它会产生以下输出：
Integer: 43 Binary equivalent: 0b101011
Python 中的八进制数
八进制数只包含 0 到 7 的数字。为了指定该整数使用八进制表示法，它需要以 "0o"（小写 O）或 "0O"（大写 O）开头。八进制数字的字面量表示如下：
a = 0O107
print(a, type(a))
它会产生以下输出：
71 <class 'int'>
注意，对象内部存储为整数。八进制数 107 的十进制等价为 71。
由于八进制数系统有 8 个符号（0 到 7），其基数为 7。因此，在使用 int() 函数将八进制字符串转换为整数时，需要将基数参数设置为 8。
a = int('20', 8)
print(a, type(a))
它会产生以下输出：
16 <class 'int'>
十进制等价于八进制 30 的值为 16。
在下面的代码中，从八进制表示法中获得了两个整数对象，并对其进行了加法操作。
a = 0O56
print("a:", a, "type:", type(a))
b = int("0O31", 8)
print("b:", b, "type:", type(b))
c = a + b
print("addition:", c)
它会产生以下输出：
a: 46 type: <class 'int'>
b: 25 type: <class 'int'>
addition: 71
要获得一个整数的八进制字符串，使用 oct() 函数。
a = oct(71)
print(a, type(a))
Python 中的十六进制数
正如其名，十六进制数系统中有 16 个符号。它们是 0-9 和 A 到 F。前 10 个数字与十进制数字相同。字母 A、B、C、D、E 和 F 分别相当于 11、12、13、14、15 和 16。这些字母符号可以使用大写或小写。
对于十六进制表示法的整数字面量，用 "0x" 或 "0X" 前缀。
a = 0XA2
print(a, type(a))
它会产生以下输出：
162 <class 'int'>
要将一个十六进制字符串转换为整数，需要在 int() 函数中将基数设置为 16。
a = int('0X1e', 16)
print(a, type(a))
尝试以下代码片段。它接收一个十六进制字符串，并返回相应的整数。
num_string = "A1"
number = int(num_string, 16)
print("Hexadecimal:", num_string, "Integer:", number)
它会产生以下输出：
Hexadecimal: A1 Integer: 161
然而，如果字符串包含除了十六进制符号表之外的任何符号，将会产生错误。
num_string = "A1X001"
print(int(num_string, 16))
上述程序会产生以下错误：
Traceback (most recent call last):
File "/home/main.py", line 2, in ?
print(int(num_string, 16))
ValueError: invalid literal for int() with base 16: 'A1X001'
Python 的标准库中有一个 hex() 函数，可以使用它来获得一个整数的十六进制等价字符串。
a = hex(161)
print(a, type(a))
它会产生以下输出：
0xa1 <class 'str'>
尽管一个整数可以被表示为二进制、八进制或十六进制，但在内部它仍然是整数。因此，在执行算术操作时，表示形式无关紧要。
a = 10
b = 0b10
c = 0O10
d = 0XA
e = a + b + c + d
print("addition:", e)
它会产生以下输出：
addition: 30
Python - 浮点数
一个浮点数有一个整数部分和一个小数部分，两者由小数点符号（.）分隔。默认情况下，这个数字是正数；如果是一个负数，则前面加上一个负号（-）符号。
一个浮点数是 Python 的 float 类的对象。存储一个 float 对象可以通过字面量表示、使用一个表达式的值，或者使用 float() 函数的返回值。
使用字面量是最直接的方式。只需将一个带有小数部分的数字赋给一个变量即可。以下每条语句都声明了一个 float 对象：
>>> a = 9.99
>>> b = 0.999
>>> c = -9.99
>>> d = -0.999
在 Python 中，对于一个浮点数小数点后可以有多少位数字没有限制。然而，为了缩短表示形式，使用了 E 或 e 符号。E 表示 10 的幂次方。例如，E4 是 10 的 4 次方，而 e-3 是 10 的 -3 次方。
在科学计数法中，数字有一个系数和指数部分。系数应该是一个大于等于 1 但小于 10 的浮点数。因此，1.23E+3、9.9E-5 和 1E10 都是带有科学计数法的浮点数的例子。
>>> a = 1E10
>>> a
10000000000.0
>>> b = 9.90E-5
>>> b
9.9e-05
>>> 1.23E3
1230.0
创建一个 float 对象的第二种方式是间接的，即使用表达式的结果。这里，两个浮点数的商被赋给一个变量，该变量引用一个 float 对象。
a = 10.33
b = 2.66
c = a / b
print("c:", c, "type", type(c))
它会产生以下输出：
c: 3.8834586466165413 type <class 'float'>
Python 的 float() 函数返回一个 float 对象，解析一个数字或一个适当内容的字符串。如果没有在括号内给出参数，它返回 0.0；对于 int 参数，则添加一个小数部分为 0。
>>> a = float()
>>> a
0.0
>>> a = float(10)
>>> a
10.0
即使整数是以二进制、八进制或十六进制表示的，float() 函数也会返回一个带有小数部分为 0 的 float。
a = float(0b10)
b = float(0O10)
c = float(0xA)
print(a, b, c, sep=",")
它会产生以下输出：
2.0,8.0,10.0
float() 函数可以从包含浮点数的字符串中检索出一个浮点数，该字符串可以是标准小数点格式，也可以具有科学计数法。
a = float("-123.54")
b = float("1.23E04")
print("a=", a, "b=", b)
它会产生以下输出：
a= -123.54 b= 12300.0
在数学中，无穷大是一个抽象的概念。实际上，无法在任何数量的内存中存储无限大的数字。然而，对于大多数计算机硬件配置来说，一个非常大的数（10 的 400 次方）则表示为 Inf。如果你使用 "Infinity" 作为 float() 函数的参数，它会返回 Inf。
a = 1.00E400
print(a, type(a))
a = float("Infinity")
print(a, type(a))
它会产生以下输出：
inf <class 'float'>
inf <class 'float'>
另一个这样的实体是 Nan（代表“不是一个数字”）。它表示任何未定义或不可表示的值。
>>> a = float('Nan')
>>> a
Nan
Python - 复数
在这一节中，我们将详细了解 Python 中的复数数据类型。复数在电磁学、电子学、光学和量子理论中的数学方程和定律中都有应用。傅立叶变换使用复数。它们用于波函数计算、滤波器设计、数字电子信号完整性、射电天文学等领域。
一个复数由一个实部和一个虚部组成，中间用 "+" 或 "−" 分开。实部可以是任何浮点数（或本身也是一个复数）。虚部也是浮点数/复数，但乘以一个虚数。
在数学上，虚数 "i" 被定义为 -1 的平方根。因此，复数被表示为 "x+yi"，其中 x 是实部，"y" 是虚部的系数。
通常情况下，为了避免与电流理论中的使用混淆，符号 "j" 被用于替代 "i" 作为虚数。Python 也使用 "j" 作为虚数。因此，在 Python 中，"x+yj" 是复数的表示形式。
就像 int 或 float 数据类型一样，一个复数对象可以用字面量表示或使用 complex() 函数来形成。所有以下语句都形成一个复数对象。
>>> a = 5 + 6j
>>> a
(5+6j)
>>> type(a)
<class 'complex'>
>>> a = 2.25 - 1.2J
>>> a
(2.25-1.2j)
>>> type(a)
<class 'complex'>
>>> a = 1.01E-2 + 2.2e3j
>>> a
(0.0101+2200j)
>>> type(a)
<class 'complex'>
请注意，实部以及虚部的系数必须是浮点数，并且它们可以用标准的小数点表示或科学计数法表示。
Python 的 complex() 函数有助于形成一个 complex 类型的对象。该函数接受实部和虚部的参数，并返回复数。
complex() 函数有两个版本，带两个参数和带一个参数。使用带两个参数的 complex() 很简单。它使用第一个参数作为实部，第二个作为虚部的系数。
a = complex(5.3, 6)
b = complex(1.01E-2, 2.2E3)
print("a:", a, "type:", type(a))
print("b:", b, "type:", type(b))
它会产生以下输出：
a: (5.3+6j) type: <class 'complex'>
b: (0.0101+2200j) type: <class 'complex'>
在上面的例子中，我们使用了 x 和 y 作为浮点参数。它们甚至可以是复数类型。
a = complex(1 + 2j, 2 - 3j)
print(a, type(a))
它会产生以下输出：
(4+4j) <class 'complex'>
对以上例子感到惊讶？将 "x" 设为 1+2j 和 "y" 设为 2-3j。试着手动计算 "x+yj" 就会明白。
complex(1+2j, 2-3j)
=(1+2j)+(2-3j)*j
=1+2j +2j+3
=4+4j
如果你只为 complex() 函数提供一个数字参数，它将其视为实部的值；而虚部则设置为 0。
a = complex(5.3)
print("a:", a, "type:", type(a))
它会产生以下输出：
a: (5.3+0j) type: <class 'complex'>
complex() 函数也可以解析一个字符串为复数，如果它的唯一参数是一个含有复数表示形式的字符串。
在下面的代码段中，用户被要求输入一个复数。这个输入被作为参数使用。因为 Python 把输入读取为字符串，所以函数从中提取复数对象。
a = "5.5+2.3j"
b = complex(a)
print("Complex number:", b)
它会产生以下输出：
Complex number: (5.5+2.3j)
Python 内置的 complex 类有两个属性 real 和 imag —— 它们从对象中返回实部和虚部的系数。
a = 5 + 6j
print("Real part:", a.real, "Coefficient of Imaginary part:", a.imag)
它会产生以下输出：
Real part: 5.0 Coefficient of Imaginary part: 6.0
complex 类还定义了一个 conjugate() 方法。它返回另一个复数，但虚部的符号相反。例如，x+yj 的共轭是 x-yj。
>>> a = 5 - 2.2j
>>> a.conjugate()
(5+2.2j)
数字类型转换
Python 在表达式中隐式地将数字转换为一个共同的类型进行求值，如果表达式中包含混合类型。但有时，你需要显式地将一个数字从一种类型转换为另一种类型，以满足运算符或函数参数的要求。
使用 int(x) 将 x 转换为一个普通的整数。
使用 long(x) 将 x 转换为一个长整数。
使用 float(x) 将 x 转换为一个浮点数。
使用 complex(x) 将 x 转换为一个实部为 x 和虚部为 0 的复数。同样地，使用 complex(x, y) 将 x 和 y 转换为一个实部为 x 和虚部为 y 的复数。x 和 y 都应该是数值表达式。
理论和表示函数
Python 在 math 模块中包括了以下理论和表示函数：
| 序号 |
函数 & 描述 |
| 1 |
math.ceil(x) |
| |
x 的天花板：不大于 x 的最小整数 |
| 2 |
math.comb(n, k) |
| |
用于找到从 n 个不同元素中选择 k 个元素的组合数，不重复且无顺序 |
| 3 |
math.copysign(x, y) |
| |
返回一个绝对值为 x 但符号为 y 的浮点数 |
| 4 |
math.cmp(x, y) |
| |
用于比较两个对象的值。此函数在 Python3 中已废弃 |
| 5 |
math.fabs(x) |
| |
计算给定整数的绝对值 |
| 6 |
math.factorial(n) |
| |
计算给定整数的阶乘 |
| 7 |
math.floor(x) |
| |
计算给定整数的地板值 |
| 8 |
math.fmod(x, y) |
| |
math 模块中的 fmod() 函数返回与 % 运算符相同的结果。但是 fmod() 比 % 运算符提供了更精确的模运算结果 |
| 9 |
math.frexp(x) |
| |
计算给定数字的尾数和指数 |
| 10 |
math.fsum(iterable) |
| |
返回可迭代对象中所有数值项的浮点和 |
| 11 |
math.gcd(*integers) |
| |
计算所有给定整数的最大公约数 |
| 12 |
math.isclose() |
| |
用于确定两个给定的数值是否接近 |
| 13 |
math.isfinite(x) |
| |
判断给定的数字是否为有限的 |
| 14 |
math.isinf(x) |
| |
判断给定的值是否为无穷大（正无穷或负无穷） |
| 15 |
math.isnan(x) |
| |
判断给定的数字是否为 “NaN”（非数字） |
| 16 |
math.isqrt(n) |
| |
计算给定非负整数的整数平方根 |
| 17 |
math.lcm(*integers) |
| |
计算给定整数参数的最小公倍数 |
| 18 |
math.ldexp(x, i) |
| |
返回第一个数字与第二个数字的指数的乘积。因此 ldexp(x, y) 返回 x * 2 ** y。这是 frexp() 函数的逆操作 |
| 19 |
math.modf(x) |
| |
以二元组的形式返回 x 的小数部分和整数部分 |
| 20 |
math.nextafter(x, y, steps) |
| |
返回 x 后向 y 方向的下一个浮点值 |
| 21 |
math.perm(n, k) |
| |
计算排列数。它返回从 n 个不同元素中选择 k 个元素的方法数，不重复且有顺序 |
| 22 |
math.prod(iterable, *, start) |
| |
计算给定作为参数的可迭代对象（列表、元组）中所有数值项的乘积 |
| 23 |
math.remainder(x, y) |
| |
返回 x 相对于 y 的余数。这是 x - n * y 的差值，其中 n 是最接近 x / y 的商的整数 |
| 24 |
math.trunc(x) |
| |
返回数字的整数部分，移除小数部分。trunc() 对于正数 x 等同于 floor()，对于负数 x 等同于 ceil() |
| 25 |
math.ulp(x) |
| |
返回浮点数 x 的最低有效位的值 |
幂和对数函数
| 序号 |
函数 & 描述 |
| 1 |
math.cbrt(x) |
| |
计算数字的立方根 |
| 2 |
math.exp(x) |
| |
计算 x 的指数 ex |
| 3 |
math.exp2(x) |
| |
返回 2 的 x 次幂。等同于 2 ** x |
| 4 |
math.expm1(x) |
| |
返回 e 的 x 次幂减去 1。这里的 e 是自然对数的底 |
| 5 |
math.log(x) |
| |
计算 x 的自然对数，对于 x > 0 |
| 6 |
math.log1p(x) |
| |
返回 1 + x 的自然对数（以 e 为底）。结果在 x 接近零时准确计算 |
| 7 |
math.log2(x) |
| |
返回 x 的以 2 为底的对数。这通常比 log(x, 2) 更准确 |
| 8 |
math.log10(x) |
| |
返回 x 的以 10 为底的对数，对于 x > 0 |
| 9 |
math.pow(x, y) |
| |
返回 x 的 y 次幂 |
| 10 |
math.sqrt(x) |
| |
返回 x 的平方根，对于 x > 0 |
三角函数
Python 在 math 模块中包括了以下执行三角计算的函数：
| 序号 |
函数 & 描述 |
| 1 |
math.acos(x) |
| |
返回 x 的反余弦值，单位为弧度 |
| 2 |
math.asin(x) |
| |
返回 x 的反正弦值，单位为弧度 |
| 3 |
math.atan(x) |
| |
返回 x 的反正切值，单位为弧度 |
| 4 |
math.atan2(y, x) |
| |
返回 atan(y / x)，单位为弧度 |
| 5 |
math.cos(x) |
| |
返回 x 弧度的余弦值 |
| 6 |
math.sin(x) |
| |
返回 x 弧度的正弦值 |
| 7 |
math.tan(x) |
| |
返回 x 弧度的正切值 |
| 8 |
math.hypot(x, y) |
| |
返回欧几里得范数，sqrt(x * x + y * y) |
角度转换函数
Python math 模块提供的角度转换函数如下：
| 序号 |
函数 & 描述 |
| 1 |
math.degrees(x) |
| |
将给定的角度从弧度转换为度 |
| 2 |
math.radians(x) |
| |
将给定的角度从度转换为弧度 |
数学常量
Python math 模块定义了以下数学常量：
| 序号 |
常量 & 描述 |
| 1 |
math.pi |
| |
代表数学常数 π，其值精确到 “3.141592…” |
| 2 |
math.e |
| |
代表数学常数 e，其值精确到 “2.718281…” |
| 3 |
math.tau |
| |
代表数学常数 Tau（记作 τ）。它相当于圆周率与半径之比，等于 2π |
| 4 |
math.inf |
| |
代表正无穷。对于负无穷使用 -math.inf |
| 5 |
math.nan |
| |
代表一个浮点数“非数字”（NaN）值。其值等同于 float('nan') 的输出 |
双曲函数
双曲函数是基于双曲线而不是圆的三角函数的类比。Python math 模块中的双曲函数如下：
| 序号 |
函数 & 描述 |
| 1 |
math.acosh(x) |
| |
计算给定值的反双曲余弦 |
| 2 |
math.asinh(x) |
| |
计算给定数的反双曲正弦 |
| 3 |
math.atanh(x) |
| |
计算给定数的反双曲正切 |
| 4 |
math.cosh(x) |
| |
计算给定值的双曲余弦 |
| 5 |
math.sinh(x) |
| |
计算给定数的双曲正弦 |
| 6 |
math.tanh(x) |
| |
计算给定数的双曲正切 |
特殊函数
Python math 模块提供的特殊函数如下：
| 序号 |
函数 & 描述 |
| 1 |
math.erf(x) |
| |
返回给定参数的高斯误差函数的值 |
| 2 |
math.erfc(x) |
| |
误差函数的补函数。erf(x) 的值等同于 1 - erf(x) |
| 3 |
math.gamma(x) |
| |
用于计算复数的阶乘。它定义于除了非正整数的所有复数 |
| 4 |
math.lgamma(x) |
| |
计算 x 处伽玛函数的绝对值的自然对数 |
随机数函数
随机数用于游戏、模拟、测试、安全性和隐私应用。Python 在 random 模块中包含了以下函数：
| 序号 |
函数 & 描述 |
| 1 |
random.choice(seq) |
| |
从列表、元组或字符串中随机选择一项 |
| 2 |
random.randrange([start,] stop [,step]) |
| |
从 range(start, stop, step) 中随机选择一个元素 |
| 3 |
random.random() |
| |
一个随机浮点数 r，使得 0 <= r < 1 |
| 4 |
random.seed([x]) |
| |
设置用于生成随机数的初始整数值。在调用 random 模块的其他函数之前调用此函数。返回 None |
| 5 |
random.shuffle(seq) |
| |
用于随机化给定序列的项 |
| 6 |
random.uniform(a, b) |
| |
返回一个随机浮点数 r，使得 a <= r < b |
内置数学函数
以下是 Python 解释器内置的数学函数，因此您不需要从任何模块导入它们：
| 序号 |
函数 & 描述 |
| 1 |
Python abs() function |
| |
返回 x 的绝对值，即 x 与零之间的正值距离 |
| 2 |
Python max() function |
| |
返回其参数中的最大值或最大数字来自可迭代对象（列表或元组） |
| 3 |
Python min() function |
| |
返回其参数中的最小值，即最接近负无穷的值，或来自可迭代对象（列表或元组）的最小数字 |
| 4 |
Python pow() function |
| |
返回 x 的 y 次幂。等同于 x ** y |
| 5 |
Python round() Function |
| |
返回四舍五入到小数点后 n 位的 x 值 |
| 6 |
Python sum() function |
| |
返回任何可迭代对象（列表或元组）中所有数值项的总和。它有一个默认为 0 的可选起始参数。如果给出，列表中的数字将加到起始值上 |