Python数值数据类型详解

更多内容，可以微信搜索【公】【众】【号】【郑大钱呀】，关注我们，一起学技术！

1.1 简述

Python中的常用数值类型包括整型、浮点数、复数以及布尔型，本章主要讲述它们的定义、相关方法以及数据类型间的相互转换，下面我们就开始本期的学习。

1.2 整型、浮点型、复数及布尔型

1.2.1 整型

所谓整型就是整数，包含正整数和复整数，Python3中的整型和Java等其它编程语言中的整型有些不一样，在Python3中的整型是没有大小限制的，只有一种类型就是整型（int型），而在Java中的整型还细分为short、long、int。在声明整型变量的时候默认是以十进制声明的，我们也可以使用二进制（0b开头）、八进制（0o开头）、十六进制声明（0x开头）。相关代码示例如下：

print(100,type(100)) #正整数
print(-100,type(-100)) #负整数
print(0b1100100,type(0b1100100)) #使用二进制表示整数
print(0o144,type(0o144)) #使用八进制表示整数
print(0x64,type(0x64)) #使用十六进制表示整数
print(1000000000000000000000,type(1000000000000000000000)) #很大的数字

输出结果如下：

100 <class 'int'>
-100 <class 'int'>
100 <class 'int'>
100 <class 'int'>
100 <class 'int'>
1000000000000000000000 <class 'int'>

1.2.2 浮点型

浮点数其实就是小数，由于小数点的位置是可变的，所以也称为浮点数，浮点数也可以使用科学计数法表示。相关代码示例如下：

print(1.04,type(1.04))
print(104e-2,type(104e-2)) #使用科学计数法表示浮点数

输出结果如下：

1.04 <class 'float'>
1.04 <class 'float'>

1.2.3 复数

Python中复数的概念和数学中的概念是一样的，形如z=a+bj(a,b均为实数)的数称为复数，a称为实数的实部，b称为实数的虚部，j称为实数的虚数单位。在Python中如何声明一个复数呢，方式有两种：一种是直接声明，另一种通过complex(实部，虚部)函数，示例如下：

a=1+5j #直接声明
b=complex(1,5) #使用complex函数声明复数
print(a)
print(b)

输出结果如下：

(1+5j)
(1+5j)

我们也可以获取复数的虚部、实部以及求复数的共轭复数（一个复数的共轭复数就是实部相同，虚部互为相反数），示例代码如下：

a=1+5j #声明一个复数
print("实部",a.real) #获取复数的实部
print("虚部",a.imag) #获取复数的虚部
print("共轭复数",a.conjugate()) #求复数的共轭复数

输出结果如下：

实部 1.0
虚部 5.0
共轭复数 (1-5j)

复数运算还有很多，这里就不详细说了。

1.2.4 布尔类型

布尔值通俗的讲就是对与错，在Python3中对用True表示，错用False表示，也可以使用数值表示即所有非0的整数都是True，0是False,相关代码示例如下：

if 0:
	print("False:",1!=1)
if 1:
	print("True:",1==1)

输出结果如下：

True: True

1.3 Python数值类型常用方法

1.3.1 bin()函数

将十进制数转换成二进制

a=5
print(bin(a)) #将十进制数转换成二进制

输出结果如下：

0b101

1.3.2 oct()函数

将十进制数转换成八进制

a=5
print(oct(a)) #将十进制数转换成八进制

输出结果如下：

0o5

1.3.3 hex()函数

将十进制数转换成十六进制

a=5
print(hex(a)) #将十进制数转换成十六进制

输出结果如下：

0x5

1.3.4 abs()函数

abs()函数的作用就是返回绝对值，代码示例如下：

a=-1
b=-1.5
c=1-1j
print("a",abs(a)) #求负整数的绝对值
print("b",abs(b)) #求小数的绝对值
print("c",abs(c)) #求复数的绝对值

输出结果如下：

a 1
b 1.5
c 1.4142135623730951

代码说明：这里重点说一下复数的绝对值，其实复数没有绝对值的概念，这里操作叫取模，也就是将实部平方加上虚部平方，然后再对他们的和进行开平方，所以1-1j1的取模结果如下：

$$\sqrt{1^2+(-1{)}^2}=\sqrt{2}\approx 1.412135623730951$$

1.3.5 sqrt()函数

sqrt()函数的作用是求平方根，返回一个浮点数，需要注意的是sqrt()函数不可直接访问，需要导入math模块后才能使用，代码示例如下：

import math #导入math模块
res=math.sqrt(4) #求平方根
print(res,type(res))

输出结果如下：

2.0 <class 'float'>

此外要说明的就是，负数没有平方根以及该方法不能用来求复数的平方根，复数的平方根和这个开平方完全是两个概念。

1.3.6 max()函数

此函数用来求一组数中的最大值，示例代码如下：

print(max(1,2,3,4,5,6,7,8,9))

输出结果如下：

9

1.3.7 min()函数

此函数用来求一组数中的最小值，示例代码如下：

print(min(1,2,3,4,5,6,7,8,9))

输出结果如下：

1

1.3.8 round()函数

此函数的作用是对浮点数进行四舍五入，你可以指定返回结果的小数位，如果不指定则默认返回整数，示例代码如下：

print(round(1.556)) #不指定返回的小数位
print(round(1.556,2)) #指定返回小数位

输出结果如下：

2
1.56

不过需要注意的是round()函数并不所有时候都能正确的四舍五入，比如下面的示例：

print(round(2.5))

输出结果如下：

2

根据我们的常识，我们知道2.5四舍五入不应该是3嘛，怎么是2.5呢，这是为什么呢，这是因为round对小数的精确度采用了四舍六入五成双的方式，什么意思呢，如果要求保留位数的后一位<=4则舍去，示例代码如下：

print(round(2.4))

2

如果保留位数的后一位">=6"则进位，示例代码如下：

print(round(2.6))

输出结果如下：

3

如果保留位数的后一位等于5，且该位数后面有数字则进位，如果没有则不进位，如果没有则不进位，示例代码如下：

print(round(2.5))
print(round(2.51))

输出结果如下：

2
3

现在看来使用round()函数实现四舍五入貌似不是那么可靠，如果现在我们要实现数学意义上的四舍五入，那怎么办呢？在Python中提供了一个decimal模块，它可以做到数学意义上的四舍五入，这里我们先不细讲，先给个示例，代码如下：

#导入decimal模块
from decimal import Decimal,ROUND_HALF_UP
#构造一个Decimal对象
dec=Decimal('2.5')
#quantize()方法作用是将数字四舍五入为固定指数
res=dec.quantize(Decimal('0'),rounding=ROUND_HALF_UP)
print(res) #输入结果

输出结果如下：

3

1.4 常用数据类型转换

在学习数据类型转换前，我们先看一个示例，代码如下：

num=5
str='Persons'
print(num+str)

输出结果如下：

TypeError
<ipython-input-4-509b79d44ae3> in <module>
	1 num=5
	2 str='Persons'
--->3 print(num+str)
TypeError:unsupported operand type(S) for+:'int'and'str'

从上面代码中，我们发现报错了，报错的原因显示的是整型的数据和字符串数据类型无法直接拼接，这个时候就需要对整型数据类型进行转换，将其转换成字符串类型，然后才能进行拼接。上面的示例只是数据类型转换的场景之一，在开发的过程中可能会出现很多这样的场景，所以这就是我们为什么要学习数据类型转换的原因之一，下面我们开始学习数据类型转换，数据类型转换通常分为两类：一类是自动转换，所谓自动转换就是低精度数据类型会向高精度的数据类型转换，比如整型和浮点型运算时，会自动转换成浮点型，所以结果也是浮点型，示例代码如下：

a=1
b=1.2
print(a+b,type(a+b))

输出结果如下：

2.2 <class 'float'>

另一类就是强制转换，比如整型和字符串类型拼接的时候需要先将整型数据强制转换成字符串，然后才能进行拼接，否则就会报错，Python中常见的强制转换方法如下：

1.4.1 int()函数

将对应数据类型转换成整型，示例如下：

• 将字符串转换成整型

a="555"
res=int(a) #将字符型转换成整型
print("转换前值：",a,"转换后值：",res)
print("转换前数据类型：",type(a),"转换后数据类型：",type(res))

输出结果如下：

转换前值：555 转换后值：555
转换前数据类型：<class 'str'>转换后数据类型：<class 'int'>

• 将浮点数转换成整型

a=5.20
res=int(a) #将浮点数转换成整型
print("转换前值：",a,"转换后值：",res)
print("转换前数据类型：",type(a),"转换后数据类型：",type(res))

输出结果如下：

转换前值：5.2 转换后值：5
转换前数据类型：<class 'flaot'> 转换后数据类型：<class 'int'>

需要注意的是，当浮点型转换成整型的时候，由于是高精度类型向低精度转换，所以会损失精度，这里的损失方式是直接对小数位截断，不会进行任何四舍五入，哪怕就是5.99转换成整型也依然是5

• 将布尔型转换成整型：

a=True
b=False
res=int(a) #将布尔值转换成整型
resl=int(b) #将布尔值转换成整型
print("转换前值：",a,b,"转换后值：",res,resl)
print("转换前数据类型：",type(a),"转换后数据类型：",type(res))

输出结果如下：

转换前值：True False 转换后值：1 0
转换前数据类型：<class 'bool'> 转换后数据类型：<class 'int'>

代码解释：True转换成整型就是1，False转换成整型就是0

• 补充：int()函数除了可以做数据类型转换外，还可以将二进制、八进制、十六进制转换成十进制数。

1.4.2 str()函数

将对应数据类型转换成字符串型，该函数可以将整型、浮点型、布尔型、元组、列表等其他数据类型转换成字符串，示例如下：

print("转换前类型：",type(1),"转换后类型："，type(str(1)),"转换后值",str(1))
print("转换前类型：",type(1.23),"转换后类型："，type(str(1.23)),"转换后值",str(1.23))
print("转换前类型：",type(True),"转换后类型："，type(str(True)),"转换后值",str(True))
print("转换前类型：",type([1,2]),"转换后类型："，type(str(1,2)),"转换后值",str([1,2]))
print("转换前类型：",type((1,2)),"转换后类型："，type(str((1,2))),"转换后值",str((1,2)))

输出结果如下：

转换前类型: <class 'int'> 转换后类型: <class 'str'> 转换后值 1
转换前类型: <class 'float'> 转换后类型: <class 'str'> 转换后值 1.23
转换前类型: <class 'bool'> 转换后类型: <class 'str'> 转换后值 True
转换前类型: <class 'list'> 转换后类型: <class 'str'> 转换后值 [1,2]
转换前类型: <class 'tuple'> 转换后类型: <class 'str'> 转换后值 (1,2)

1.4.3 float()函数

将对应数据转换为浮点型，示例如下：

• 将整数、字符串、布尔值转换成浮点型

print("转换前类型：",type(1),"转换后类型：",type(float(1)),"转换后值",float(1))
print("转换前类型：",type('33'),"转换后类型：",type(float('33')),"转换后值",float('33'))
print("转换前类型：",type(True),"转换后类型：",type(float(True)),"转换后值",float(True))

输出结果如下：

转换前类型:<class 'int'> 转换后类型:<class 'float'> 转换后值1.0
转换前类型:<class 'str'> 转换后类型:<class 'float'> 转换后值33.0
转换前类型:<class 'bool'> 转换后类型:<class 'float'> 转换后值1.0

1.4.4 bool()函数

将对应数据转换成布尔值，示例如下：

• 将整型、浮点型、字符串转换成布尔值

print("转换前类型：",type(1),"转换后类型：",type(bool(1)),"转换后值",bool(1))
print("转换前类型：",type(0.0),"转换后类型：",type(bool(0.0)),"转换后值",bool(0.0))
print("转换前类型：",type('33'),"转换后类型：",type(bool('33')),"转换后值",bool('33'))

输出结果如下：

转换前类型:<class 'int'> 转换后类型:<class 'bool'> 转换后值True
转换前类型:<class 'float'> 转换后类型:<class 'bool'> 转换后值False
转换前类型:<class 'str'> 转换后类型:<class 'bool'> 转换后值True

1.4.5 list()函数

将对应的类型转换成列表，具体列表的详细讲解后面的章节中讲解，包括下面的元组内容。

• 将字符串转换成列表

String = 'LingQi'
res = list(string) #将字符串转换成列表
print("转换前值",my_tuple,"转换后值",res)
print("转换前类型",type(string),"转换后类型",type(res))

输出结果如下：

转换前值 LingQi 转换后值 ['L','i','n','g','Q','i']
转换前类型 <class 'str'> 转换后类型 <class 'list'>

• 将元组转换成列表

my_tuple=('L','i','n','g','Q','i') #定义一个元组
res=list(my_tuple) #将元组转换成列表
print("转换前值",my_tuple,"转换后值",res)
print("转换前类型",type(string),"转换后类型",type(res))

输出结果如下：

转换前值（'L','i','n','g','Q','i'） 转换后值['L','i','n','g','Q','i']
转换前类型 <class 'tuple'> 转换后类型 <class 'list'>

1.4.6 tuple()函数

将对应的类型转换成元组

• 将字符串转换成元组

my_list=[1,2,3,4,5,6]
res=tuple(my_list) #将列表转换成元组
print("转换前值",string,"转换后值",res)
print("转换前类型",type(string),"转换后类型",type(res))

输出结果如下：

转换前值 LingQi 转换后值 ('L','i','n','g','Q','i')
转换前类型 <class 'str'> 转换后类型 <class 'tuple'>

• 将列表转换成元组

my_list=[1,2,3,4,5,6]
res=tuple(my_list) #将列表转换成元组
print("转换前类型",type(my_list),"转换后类型",type(res))
print("转换前值",my_list,"转换后值",res)

输出结果如下：

转换前类型 <class 'list'> 转换后类型 <class 'tuple'>
转换前值 [1,2,3,4,5,6] 转换后值 (1,2,3,4,5,6)