Python 数字

大多数情况下，您在所做的任何工作中都会处理数字。显然，任何计算机应用都会处理数字。因此，编程语言（包括Python）都内置了存储和处理数字数据的支持。

在本章中，我们将详细了解Python数值类型的属性。

Python解释器内置了三种数字类型：整数( int )、浮点数( float )和复数( complex )。Python还有一种内置的布尔数据类型叫做 bool 。它可以被视为int类型的子类型，因为它的两个可能值True和False分别表示整数1和0。

Python整数

在Python中，没有存储小数部分的数被称为整数。（注意，如果一个数的小数部分为0，并不意味着它是一个整数。例如，数值为1.0的数并不是整数，它是一个小数，小数部分为0，数值为1.）一个整数可以是零、正数或负整数。例如，1234、0、-55。

有三种方法可以形成一个整数对象：通过字面表示、任何求值为整数的表达式以及使用 int() 函数。

字面是一种在源代码中直接表示常数的表示法。例如 –

>>> a =10

然而，请看下面整数变量c的赋值。

a=10
b=20
c=a+b
print ("a:", a, "type:", type(a))

它将产生以下 输出 −

a: 10 type: <class 'int'>

这里，c确实是一个整数变量，但先计算表达式a+b，并将其值间接赋给c。

形成整数对象的第三种方法是使用int()函数的返回值。它将浮点数或字符串转换为整数。

>>> a=int(10.5)
>>> b=int("100")

你可以用二进制、八进制或十六进制表示一个整数。然而，在内部，对象存储为一个整数。

二进制数

一个只由二进制数字（1和0）组成的数字，并以0b为前缀的数字是一个二进制数。如果你将一个二进制数赋值给一个变量，它仍然是一个整数变量。

要以二进制形式表示一个整数，可以直接将其作为文本值存储，或者使用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。

在下面的代码中，从八进制表示中获得了两个整数对象，并进行了它们的相加操作。

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

将一个十六进制字符串转换为整数，将基数设为16在 int() 函数中。

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)

它将产生以下 output −

addition: 30

Python 浮点数

浮点数由整数部分和小数部分组成，以小数点符号 (.) 分隔。默认情况下，该数为正数，对于负数，需要在前面加上减号 (-) 符号。

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

使用文字表示法是最直接的方法。只需将具有小数部分的数字赋给一个变量。以下每个语句都声明了一个浮点对象。

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

在Python中，浮点数的小数点后可以有任意多位。然而，为了缩短表示，会使用 E 或 e 符号。E代表10的幂次。例如，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

在数学中，无穷是一个抽象的概念。从物理上来看，无限大的数永远无法在任何内存中存储。然而，对于大多数计算机硬件配置，一个非常大的数，比如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的平方根(√−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)