数字类型 在 Pyhton 中非常常见，经常用于数字之间的运算、大小比较、条件判断等等。数字类型包括：整型、浮点型、复数型、布尔型。其中布尔型属于特殊的数字类型。

1. 整型 int

1）整型的介绍

整型，是我们在程序中使用最广泛的一种数据类型。在 Python 中用 int 来表示，也就是 integer。通俗来说就是我们的所讲的整数，包括正整数、负整数和 0。整型的表现形式如 6，100，-135 等等。可以通过type来查看数据类型。

print(type(1))

print(type(-23))

print(type(0))

在 Python 2.x 中，整型还被分为整型 int 和 长整型 long。而 Python 3.x 中，整形与长整形进行了无缝结合，也就是现在的整形，长度在理论上来说是不受限制的，但是由于计算机内存的限制，实际上是不能无限大的。

在32位系统中，整形的范围在-2**31～2**31-1，即-2147483648～2147483647
在64位系统中，整型的范围在-2**63～2**63-1，即-9223372036854775808～9223372036854775807

2）整型的运算

运算就是包括加、减、乘、除、模、幂 等等运算方式，下面举几个例子：

a = 10
b = 2
c = 6

print(a + b，type(a + b))  # 输出12, <class 'int'>

print(a - b，type(a - b))  # 输出8, <class 'int'>

print(a * b，type(a * b))  # 输出20, <class 'int'>

print(a / b，type(a / b))  # 输出5.0, <class 'float'>，结果为浮点数

print(a // b，type(a // b))  # 输出5, <class 'int'>，结果为整除

print(a // c，type(a // c))  # 输出1, <class 'int'>，结果为整除，直接将小数部分丢弃

3）int() 函数

int 作为 Python 中的一种数据类型，其后面加上括号就变成一个函数。

这是 Python 解释器对 int() 函数的详细描述。该函数用来将一个实数或字符串转换成整型，如果函数内没有传入任何参数，则返回 0。

print(int())  # 输出0，不加参数，返回0

print(int(1.9))  # 输出1，浮点数转换成整数，直接丢弃小数部分，保留整数部分

print(int('123'))  # 输出123，如果是字符串，必须是数字组成的字符串，否则会报错

print(int('1.23'))  # 报错，有小数点的字符串无法被转换，因为你认为的小数点，解释器却不知道

# print(int(2j+1))  # 报错，复数不能转化成整数

int(x, base=10) 函数的第二个参数 base 是进制，代表 x 的进制。如果不写则默认使用十进制进行转换。如果给出 base，那么 x 必须是数字字符串、字节或由数字组成的字节数组。base 允许输入的范围是 0、2~36。如果 base=0，那么解释器会自动根据传入的字符进行转换。举几个例子:

'''
0b 二进制前缀
0o 八进制前缀
0x 十六进制前缀
'''
print(int('100', base=2))  # 输出4，等价'0b100'

# print(int('102', base=2))  # 报错，这个数违反2进制规则，所以会报错

print(int('100', base=8))  # 输出64，等价'0o100'

print(int('100', base=16))  # 输出256，等价'0x100'

print(int('0x100', base=16))  # 输出256

# print(int('0x100', base=2))  # 报错，'0x100'已明确表明为16进制，base如果不匹配则报错

print(int('0x100', base=0))  # 输出256，解释器自动识别，进行16进制的转换

2. 浮点型 float

Python 中的浮点数，用 float 来表示。你可以近似理解为数学中的小数。浮点型和整型在内存中的存储方式是不同的，所以需要单独成一个数据类型。

1）浮点型的介绍

浮点数有两种表示形式：正常形式(带小数点)和科学记数法。当浮点数很大或很小的情况下解释器会自动转换成科学记数法的表现形式。

print(1000000000000000.0)  # 输出1000000000000000.0

print(10000000000000000.0)  # 输出1e+16

print(11111111111111111.0)  # 输出1.1111111111111112e+16

print(0.0000123456789012345678)  # 输出1.2345678901234568e-05

仔细看上述代码，会发现浮点数的精度是有限制的。Python 中默认的浮点型精度是17位，也就是小数点后16位，尽管有16位，但是这个精确度却是越往后越不准的。这个问题在任何语言都存在。小数不精准是因为在转换成二进制的过程中会出现无限循环的情况，在约省的时候就会出现偏差。当然在普通的项目中当前的精确程度是足够的，而在某些专业项目中，有可以实现更高精度的库来协助。

2）浮点型的运算

浮点型的运算与整型的运算一样，只不过由于存储方式的限制，导致运算后的结果跟实际产生差别。

• 浮点型和整型运算会得到浮点型。

a = 6
b = 0.4

print(a + b, type(a + b))  # 输出6.4 <class 'float'>

print(a - b, type(a - b))  # 输出5.6 <class 'float'>

print(a * b, type(a * b))  # 输出2.4000000000000004 <class 'float'> 进行二进制运算时出现误差

print(a / b, type(a / b))  # 输出15.0 <class 'float'>

• 浮点型和浮点型计算显然会得到浮点型。

a = 0.5
b = 1.5

pritn(a + b, type(a + b))  # 输出2.0 <class 'float'>

pritn(a - b, type(a - b))  # 输出-1.0 <class 'float'>

# 其他计算类似，而取整除法‘//’的运算不应该运用在浮点数的计算中。

3）float() 函数

float 作为 Python 中的一种数据类型，其后面加上括号就变成一个函数。

这是 Python 解释器对 float() 函数的详细描述。该函数用来将一个实数或字符串转换成浮点型，如果函数内没有传入任何参数，则返回 0.0。

print(float())  # 输出0.0，括号内为空则默认传入0

print(float(233))  # 输出233.0，整型转换为浮点型

print(float('233'))  # 输出233.0，数字字符串转换成浮点型

print(float('233.3'))  # 输出233.3，字符串中可以识别到小数点，转换成功

# print(float(2j+1))  # 报错，不能转换复数

3. 复数型 complex

1）复数的介绍

Python 中的复数就是在数学中接触过的复数，由两部分组成：实数部分和虚数部分，表现形式为: a+bj (Python中用 j 来表示虚数部分)。其中 a 与 b 都是实数，j 为虚数单位(-1的平方根)，当虚数部分的系数 b 为零时，这个复数就是实数；当虚数部分的系数 b 不为零时，这个复数就是虚数。复数在普通项目中是用不到的，但是在工程领域的一些项目使用较多。

2）复数的运算

复数型可以与复数、浮点数、整数进行正常运算，都会得到一个复数。这里简单举几个例子

a = 3 + 2j
b = 5 + 2j

print(a - b, type(a - b))  # 输出(-2+0j) <class 'complex'>

print(a * b, type(a * b))  # 输出(11+16j) <class 'complex'>

3）complex() 函数

该函数可以传入两个参数，real 表示一个复数的实部，imag 表示复数的虚部系数。最后两个部分结合就生成了一个复数。当然这个函数也可以理解为把一个实数转换成复数，不过虚数部分肯定是 0 了。

print(complex(1),type(complex(1)))  # 输出(1+0j) <class 'complex'>

print(complex(1.5),type(complex(1.5)))  # 输出(1.5+0j) <class 'complex'>

print(complex(1, 1.5),type(complex(1, 1.5)))  # 输出(1+1.5j) <class 'complex'>

print(complex(0, 1.5),type(complex(0, 1.5)))  # 输出1.5j <class 'complex'>

4. 布尔型

Python 中的布尔型，用 bool 来表示。你可以近似理解为数学中的小数。布尔值在 Python 中主要用来做判断的依据。比如条件判断 “if” 和循环 “while” 都会用到布尔值。

1) 布尔型的介绍

布尔型在 Python 中只有两个值，分别为 True 和 False 。

print(type(True))  # 输出 <class 'bool'>

print(type(False))  # 输出 <class 'bool'>

布尔值本质上是属于整形的。从类的角度来说，bool类 是 int类 的子类，并且 bool类 不能再被子类化。

既然布尔值属于整数，那是否可以做转换呢？在做条件判断时，我们会发现非 0 数都会被解释器认为 True，那 True 是否等价于所有非 0 数值呢？

print(int(True))  # 输出 1，因为bool属于int子类，所以可以使用int()函数来做转换

print(int(False))  # 输出 0

print(True==1)  # 输出 True 在Python中True等于整数1

print(True==2)  # 输出 False 在做条件判断时，所有非0的数都被认为True，但True却不等于所有非0数

print(False==0)  # 输出 True 在Python中False等于整数0

2）布尔值的运算

既然布尔值属于整数，那是否可以运用布尔值来运算呢？答案当然是可以的，布尔值常被使用在逻辑运算中，但是不推荐直接使用布尔值来参与数学运算。首先，布尔值与整数 0 和 1 的转换来自二进制的计算机思想。布尔值的 True 和 False 其实是代表一个事物的两种矛盾状态，比如：有女朋友、没有女朋友两种状态。对应到二进制时，因为二进制只有 0 和 1，1 代表有女朋友，0 代表没有女朋友。其次，布尔值随然属于 int 的子类，但毕竟有其特殊的书写形式（True、False），直接使用在数学运算中破坏代码美感。如果有必要，可以先转换为整形后参与运算。第三，布尔值适合与逻辑运算结合使用，类似计算机中的门计算。

print(True & False)  # 输出 False

print(True | False)  # 输出 True

print(not True)  # 输出 False

3）bool() 函数

True 和 False 在 Python 中代表 真 和 假，但是不可能只用这俩货去进行所有的真假判断。其实是有很多数值、变量、运算、表达式、方法、函数等可以输出 True 或 False。

True：

• 非空数据类型，比如：非空列表、元组、字典、字符串、集合等
• 非 0 数值，包括 int、float、complex，不为 0 就行

False：

• 空数据类型，比如：空字符串 “”、空列表 []、空字典 {}、空元组 () 等。
• 数值 0
• None

通过 bool() 内置函数可以返回传入的参数的布尔值。

print(bool(""))  # 输出 False
print(bool(" "))  # 输出 True 虽然是空格，但却不是空字符串
print(bool([1, 2, 3]))  # 输出 True
print(bool({}))  # 输出 False
print(bool(1.26))  # 输出 True
print(bool(0j))  # 输出 False
print(bool(None))  # 输出 False

还有一些运算、表达式、函数等，可以直接返回布尔值，需要根据代码编写的实际情况判断。

print(1 == 2)  # 输出 False 比较运算
print("a" in "abc")  # 输出 True 成员运算
print(1==1 & 1>2)  # 输出 False 逻辑运算
print(2/1+3*4-14)  # 输出 False 数学表达式
print("a".isalpha())  # 输出 True 字符串内置函数，返回布尔值