Python - 数字

---

Python 内置支持存储和处理数字数据（Python Numbers）。大多数时候，您几乎在每个 Python 应用程序中都会使用数字。显然，任何计算机应用程序都与数字打交道。本教程将讨论不同类型的 Python 数字及其属性。

Python - 数字类型

Python 中提供了三种内置数字类型：

• 整数（int）
• 浮点数（float）
• 复数_

Python 还有一个内置的布尔数据类型，称为bool。它可以被视为int类型的子类型，因为它有两个可能的值True和False分别代表整数 1 和 0。

Python - 整数

在Python中，任何没有存储小数部分的数字都是整数。（请注意，如果数字中的小数部分为 0，并不意味着它是整数。例如数字 10.0 不是整数，它是一个小数部分为 0 的浮点数，其数值为 10。）整数可以是零、正整数或负整数。例如，1234、0、-55在Python中都表示整数。

形成整数对象的方法有3种。使用 (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")

您可以将整数表示为二进制、八进制或十六进制数。但是，该对象在内部存储为整数。

二进制数

仅由二进制数字（1 和 0）组成并以0b为前缀的数字是二进制数。如果将二进制数分配给变量，它仍然是 int 变量。

A 表示二进制形式的整数，直接将其存储为文字，或者使用 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

八进制数

八进制数仅由数字 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。

在以下代码中，从八进制表示法获取两个 int 对象并执行它们的加法。

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))

十六进制数

顾名思义，十六进制数系统中有 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

但是，如果字符串包含十六进制符号表之外的任何符号（例如 X001），则会引发以下错误 -

Traceback (most recent call last):
  File "C:\Python311\var1.py", line 4, in <module>
    number = int(num_string, 16)
ValueError: invalid literal for int() with base 16: 'X001'

Python的标准库有hex()函数，使用它可以获得整数的十六进制等值。

a=hex(161)
print (a, type(a))

它将产生以下输出-

0xa1 <class 'str'>

尽管整数可以表示为二进制、八进制或十六进制，但在内部它仍然是整数。因此，在执行算术运算时，表示形式并不重要。

a=10 #decimal
b=0b10 #binary
c=0O10 #octal
d=0XA #Hexadecimal
e=a+b+c+d

print ("addition:", e)

它将产生以下输出-

addition: 30

Python - 浮点数

浮点数具有整数部分和小数部分，由小数点符号 (.) 分隔。默认情况下，该数字为正数，为负数添加前缀短划线 (-) 符号。

浮点数是Python float 类的对象。要存储浮点对象，可以使用文字表示法、算术表达式的值或使用 float() 函数的返回值。

使用字面量是最直接的方式。只需将带有小数部分的数字分配给变量即可。以下每个语句都声明一个浮点对象。

>>> a=9.99
>>> b=0.999
>>> c=-9.99
>>> d=-0.999

在Python中，浮点数小数点后的位数没有限制。然而，为了简化表示，使用了E或e符号。E 代表“十”。例如，E4 是 10 的 4 次方（或 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

形成浮点对象的第二种方法是间接的，使用表达式的结果。这里，两个浮点数的商被分配给一个变量，该变量引用一个浮点数对象。

a=10.33
b=2.66
c=a/b

print ("c:", c, "type", type(c))

它将产生以下输出-

c: 3.8834586466165413 type <class 'float'>

Python 的 float() 函数返回一个浮点对象，如果它具有适当的内容，则解析数字或字符串。如果括号中没有给出任何参数，则返回 0.0，对于int参数，会添加带 0 的小数部分。

>>> a=float()
>>> a
0.0
>>> a=float(10)
>>> a
10.0

即使整数以二进制、八进制或十六进制表示，float() 函数也会返回小数部分为 0 的浮点数。

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

在数学中，无穷大是一个抽象的概念。从物理上来说，无限大的数字永远无法存储在任何容量的内存中。然而，对于大多数计算机硬件配置而言，Inf 表示的是 10 的 400 次方的非常大的数字。如果使用“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的平方根($\sqrt{−1}$)。因此，复数表示为“x+yi”，其中x是实部，“y”是虚部系数。

通常，虚数用符号“j”代替“I”，以避免与电学理论中电流的用法相混淆。Python 还使用“j”作为虚数。因此，“x+yj”是Python中复数的表示。

与 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() 非常简单。它使用第一个参数作为实部，第二个参数作为虚部系数。

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 的内置复杂类有两个属性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

复杂类还定义了一个conjugate()方法。它返回另一个复数，其虚数部分的符号相反。例如，x+yj 的共轭是 x-yj。

>>> a=5-2.2j
>>> a.conjugate()
(5+2.2j)