3.Python 中的基础数据类型

1 为什么要学习数据类型

变量是用来存储数据的，但是在生活中有许多不同类型的数据，例如 “我是小红” 与 3.14 ，“我是小红”这条数据是一个句子，而 3.14 是一个数字，它们是不同类型的数据，支持的操作也不一样。比如句子可以分割成词语，而数字可以进行加减。存储它们所需的空间大小也不一样。所以为了方便的存储、管理及操作不同类型的数据，Python 将数据的类别进行了划分，且每种类型支持不同的操作。

在 Python 中，我们为了应对不同的业务需求，会把数据分为不同的类型，如下图所示：

面试题：

问题：请手写出 Python 中的 7 种数据类型？

答：数值类型、布尔类型、字符串类型、列表类型、元组类型、集合类型、字典类型。

问题：如何判断一个变量到底是什么类型？

答：① 使用 type(变量名称) 方法，返回变量的数据类型。

​ ② isinstance(变量名称, 数据类型)，只能返回 True 或 False（真的还是假的）。

注意

Python **变量** 没有类型，但是 **对象** 有类型。

2 数值型

2.1 int（整型）

整数：2345, 10, 50

Python 中，除 10 进制，还有其他三种进制：

• ​二进制：以 0b 或 0B 开头的数，0 1
• ​八进制：以 0o 或 0O 开头的数，0 1 2 3 4 5 6 7
• ​十六进制：以 0x 或 0X 开头的数，0 1 2 3 4 5 6 7 8 9 a b c d e f

这三种进制可以非常方便的进行位运算操作。位运算知识后续将会介绍。

# %%

12  # 十进制
# %%

0b101  # 二进制
# %%

0o19  # 八进制中没有 9 ，报类型错误 SyntaxError
# %%

0o10  # 八进制
# %%

0xff  # 十六进制
# %%

0xf  # 十六进制
# %%

0x10  # 十六进制

使用 int() 实现类型转换

1. 浮点数直接舍去小数部分。如：int(9.9) 结果是：9。
2. 布尔值 True 转为 1，False 转为 0。如：int(True) 结果是 1。
3. 字符串符合整数格式（浮点数格式不行）则直接转成对应整数，否则报错。

# %%

# 类型转换
int(9.9)  # 浮点数直接舍去小数部分
# %%

int(True) # 布尔类型 True 为 1
# %%

int(False) # 布尔类型 False 为 0
# %%

int('456')  # 字符串符合整数格式转换成对应整数
# %%

int('3.14')  # 字符串为浮点数格式报错
# %%

int('3.14ab')  # 字符串含有非数字部分报错

自动转型

整数和浮点数混合运算时，表达式结果自动转型成浮点数。比如：2+8.0 的结果是 10.0。

# %%

# 自动转型
2 + 8.0

整数可以有多大

Python2 中，int 是 32 位，可以存储从 -2147483648 到 +2147483647 的整数（约 ± 21 亿）。long 类型是 64 位，可以存储 $-2^{63}$~$2$ 之间的数值。

Python3 中，int 可以存储任意大小的整数，long 被取消。我们甚至可以存储下面的值：

# %%

googol = 10 ** 100
googol

Python3 中可以做超大数的计算，而不会造成整数溢出，这也是 Python 特别适合科学运算的原因。

2.2 float（浮点型）

小数：3.14 或者科学计数法 314e-2。

浮点数，称为 float。

浮点数用 $a*b^{10}$ 形式的科学计数法表示。比如：3.14，表示成：314E-2 或者 314e-2。

这些数字在内存中也是按照科学计数法存储。

# %%

# 浮点数
3.14
# %%

314e-2  # 科学计数法
# %%

314E-2  # 科学计数法

类型转换和四舍五入

1. 类似于 int()，我们也可以使用 float() 将其他类型转化成浮点数。

2. 整数和浮点数混合运算时，表达式结果自动转型成浮点数。比如：2 + 8.0 的结果是 10.0。

3. round(value) 可以返回四舍五入的值。

   注：但不会改变原有值，而是产生新的值。

# %%

# 类型转换
float(10)  # 整数转浮点数
# %%

float(True)  # 布尔转浮点数
# %%

float(False)
# %%

float('123')  # 字符串转浮点数
# %%

float('123d')  # 字符串包含非数字部分，报错
# %%

# 浮点数转整数
int(3.6)  # 用 int() 转直接舍去小数部分
# %%

# round 函数精度度会受设备的精度及其他因素所影响，
# 在做精确度较高的系统时，如银行的金融系统，
# 要使用专业的数学库中的函数
round(3.6)  # 用 round() 可以实现四舍五入
# %%

import math

print(math.ceil(3.6))  # 右取整，上取整 4
print(math.floor(3.6))  # 左取整，下取整 3 与 int 函数功能相同

2.3 时间的表示

计算机中时间的表示是从 1970 年 1 月 1 日 00:00:00 开始，以毫秒（1/1000 秒）进行计算。我们也把 1970 年这个时刻称为 Unix 时间点。

这样，我们就把时间全部用数字来表示了。

Python 中可以通过 time.time() 获得当前时刻，返回的值是以秒为单位，带微秒（1/1000 毫秒）精度的浮点值。

例如：

# %%

import time
b = time.time()
print(type(b))
print(b)
# %%

int(b)
total_minutes = b / 60
total_minutes
# %%

total_minutes = b // 60
total_minutes
# %%

total_hours = total_minutes // 60
total_hours
# %%

total_days = total_hours // 24
total_days
# %%

total_years = total_days // 365
total_years

2.4 数字和算数运算符

Python 支持整数(如：50，520) 和浮点数(如：3.14，10.0，1.23e2)，我们可以对数字做如下运算。

运算符	说明	示例	结果
+	加法	3+2	5
-	减法	30-5	25
*	乘法	3*6	18
/	浮点数除法	8/2	4.0
//	整数除法	7//2	3
%	模（取余）	7%4	3
**	幂	2**3	8

# %%

a = 7 / 2  # 除法结果为小数
a
# %%

a = 7 // 2  # 整除结果为整数
a
# %%

a = 7 % 2  # 取余
a
# %%

7 % 4
# %%

2 ** 3  # 幂运算
# %%

3 / 0  # 除数为 0 ，报异常 ZeroDivisionError
# %%

divmod(10, 5)  # 返回一个元组，（整除结果, 余数）
# %%

divmod(10, 3)

使用 divmod() 函数同时得到商和余数：

>>> divmod(13, 3)
(4, 1)

divmod() 是一个函数，我们以后会详细介绍。他返回的是一个元组（后续将会学习）。

2.5 复合赋值运算符

运算符 +、-、*，/、//、**、% 和赋值符 = 结合可以构成复合赋值运算符。

a = a + 1 等价于：a += 1

运算符	例子	等价
+=	a += 2	a = a + 2
-=	a -= 2	a = a - 2
*=	a *= 2	a = a * 2
/=	a /= 2	a = a / 2
//=	a //= 2	a = a // 2
**=	a **= 2	a = a ** 2
%=	a %= 2	a = a % 2

注意

> `+=` 中间不能加空格。

3 布尔型

Python2 中没有布尔值，直接用数字 0 表示 False，用数字 1 表示 True。

Python3 中，把 True 和 False 定义成了关键字，但他们的本质还是 1 和 0，甚至可以和数字相加。

bool 类型是 int 类型的一个子类。

注意

在 Python 语言底层，会将布尔值 `True` 看作 `1`，将布尔值 `False` 看作 `0`，尽管从表面上看，`True` 和 `1`、`False` 和 `0` 是完全不同的两个值，但实际上，它们是相同的。

# %%

a = True
b = 3
a + b
# %%

b = True
isinstance(b, int)

虽然 True 代表 1，False 代表 0。但实际上，Python 中的任何一个数据对象要么是 True，要么是 False，所以直接可以在布尔测试的表达式中使用，而并非一定要去大小比较、通过函数测试等等。

if "a":
    pass
while 1:
    pass

可以通过 bool() 函数来测试数据对象、表达式是 True 还是 False。例如：

详见：bool()函数

# %%

print(bool())
print(bool(0))
print(bool(1))
print(bool('a'))
print(bool(''))

常见的数据类型真假：

1. 整数值 0、浮点数值 0.0 等、空字符串都为假。
2. None 为假。
3. 空数据对象都是假，比如 []、{}、() 等。

注意

在 Python 语言中有一些特殊的布尔类型值为 `False`，例如 `False`、`0`、`0.0`、空值 `None`、空序列对象（空列表、空元祖、空集合、空字典、空字符串）、空 range 对象、空迭代对象。其他情况，均为 `True`。

注意

元组的括号和逗号的特殊性。例如 `(())`、`(None)`、`(1)` 这些都不是元组，而是单个数据对象，加上逗号才算是元组，如 `((), )`、`(None,)`。所以，使用括号包围但却不是元组的数据，如果它们是假，则整个返回假。

3.1 比较运算符

所有比较运算符返回 1 表示真，返回 0 表示假。这分别与特殊的变量 True 和 False 等价。

以下假设变量 a 为 15，变量 b 为 30：

运算符	描述	实例
==	等于——比较对象的值是否相等	(a == b) 返 回 False
!=	不等于——比较两个对象的值是否不相等	(a != b) 返 回 True
>	大于——返回 x 是否大于 y	(a > b) 返 回 False
<	小于——返回 x 是否小于 y	(a < b) 返 回 True
>=	大于等于——返回 x 是否大于等于 y	(a >= b) 返 回 False
<=	小于等于——返回 x 是否小于等于 y	(a <= b) 返 回 True

# %%

a = 15
b = 30

print(f"a == b: {a == b}")
print(f"a != b: {a != b}")
print(f"a > b: {a > b}")
print(f"a < b: {a < b}")
print(f"a >= b: {a >= b}")
print(f"a <= b: {a <= b}")

3.2 逻辑运算符

运算符	格式	说明
or 逻辑或	x or y	x 为 True，则不计算 y，直接返回 True x 为 False，则返回 y
and 逻辑与	x and y	x 为 True，则返回 y 的值 x 为 False，则不计算 y，直接返回 False
not 逻辑非	not x	x 为 True，返回 False x 为 False，返回 True

# %%

x = True
y = False

print(f"x and y: {x and y}")
print(f"x or y: {x or y}")
print(f"not x: {not x}")
print(f"not y: {not y}")

3.3 同一运算符

同一运算符用于比较两个对象的存储单元，实际比较的是对象的地址。

运算符	描述
is	is 是判断两个标识符是不是引用同一个对象
is not	is not 是判断两个标识符是不是引用不同对象

is 与 == 区 别：

1. is 用于判断两个变量引用对象是否为同一个，即比较对象的地址。
2. == 用于判断引用变量引用对象的值是否相等，默认调用对象的 __eq__ () 方法。

# %%

a = ['str', 1]
b = ['str', 1]

print('a的地址:', id(a))
print('b的地址:', id(b))
print('a的内容:', a)
print('b的内容:', b)
print('a == b:', a == b)
print('a is b:', a is b)

整数缓存问题

• 命令行模式下，Python 仅仅对比较小的整数对象进行缓存（范围为 [-5, 256]）缓存起来，而并非是所有整数对象。
  C 语言底层用数组实现，连续分配空间，便于查找。
• 文件模式下，所有数字都会被缓存，范围是：[-∞, +∞]
  • 缓存实现：[-5, 256] 仍然底层用数组实现；不在 [-5, 256] 出现的数，缓存到链表中，不连续分配空间。

总结

1. is 比较两个对象的 id 值是否相等，是否指向同一个内存地址；
2. == 比较的是两个对象的内容是否相等，值是否相等；
3. is 运算符比 == 效率高，在变量和 None 进行比较时，应该使用 is。

# %%

a = ['str', 1]
b = ['str', 1]

print('a的地址:', id(a))
print('b的地址:', id(b))
print('a的内容:', a)
print('b的内容:', b)
print('a == b:', a == b)
print('a is b:', a is b)
# %%

# 整数缓存问题
c = 1000
d = 1000

print(f'c的内容{c}; c的地址:{id(c)}')
print(f'd的内容{d}; d的地址:{id(d)}')
print('c == d:', c == d)
print('c is d:', c is d)

注意

上面例子中**整数的缓存**案例只有在命令行模式下才能复现，在 PyCharm 等 IDE 中无法复现，因为 IDE 对其做了扩充，所有整数都会被缓存。

4 基本运算符

我们在前面讲解了 +、-、*、/、//、% 等运算符，这里我们继续讲解一些其他运算符，并进行学习和测试。

运算符	说明
and，or，not	布尔与、布尔或、布尔非
is，is not	同一性判断，判断是否为同一个对象
<，<=，>，>=，!=，==	比较值是否相当，可以连用
| ^ &	按位或，按位异或、按位与
<<，>>	移位
~	按位翻转
+，-，*，/，//，%	加，减，乘，浮点除、整数除、取余
**	幂运算

1. 比较运算符可以连用，并且含义和我们日常使用完全一致。

# %%

a = 4
3< a <10  # 关系运算符可以连用

2. 位操作

# %%

a = 0b11001
b = 0b01000

c = a | b  # 按位或
d = a & b  # 按位与
e = a ^ b  # 按位异或

print(f'c的值:{c}', f'c的二进制表示:{bin(c)}')
print(f'a:{bin(a)}')
print(f'b:{bin(b)}')
print(f'c:{bin(c)}')
print(f'd:{bin(d)}')
print(f'e:{bin(e)}')
# %%

a = 4
# 左移 1 位相当于乘以 2; 左移 2 位，相当于乘以 4
print(a << 2)
# 右移 1 位相当于除以 2
print(a >> 1)

3. 加法操作

   • 数字相加 3+2 ==> 5

     3 + 2
     

     

   • 字符串拼接 “3”+“2” ==> “32”

     '3' + '2'
     

     

   • 列表、元组等合并 [10,20,30]+[5,10,100] ==> [10,20,30,5,10,100]

     [10,20,30] + [5,10,100]
     

     

4. 乘法操作

   • 数字相乘 3 * 2 ==> 6

     3 * 2
     

     

   • 字符串复制 “sxt” * 3 ==> ”sxtsxtsxt”

     

   • 列表、元组等复制 [10,20,30] * 3 ==> [10,20,30,10,20,30,10,20,30]

     [10,20,30] * 3
     

     

5 复合赋值运算符

复合赋值可以让程序更加精炼，提高效率。

运算符	描述	示例	等价于
+=	加法赋值 字符串拼接	sum += n a += “sxt”	sum = sum + n a = a + “sxt”
-=	减法赋值	num1 -= n	num = num - n
*=	乘法赋值	a *= b	a = a * b
/=	浮点除赋值	a /= b	a = a / b
//=	整数除赋值	a //= b	a = a // b
%=	取余赋值	a %= b	a = a % b
**=	幂运算赋值	a **= 2	a = a ** 2
<<=	左移赋值	a <<= 2	a = a << 2
>>=	右移赋值	a >>= 2	a = a >> 2
&=	按位与赋值	a &= b	a = a & b
|=	按位或赋值	a |= b	a = a | b
^=	按位异或赋值	a ^= b	a = a ^ b

注：与 C 和 JAVA 不一样，Python 不支持自增 (++) 和自减 (--)

6 运算符优先级问题

如下优先级，从高到低。

运算符	描述
**	指数 (最高优先级)
~	按位翻转
* / % //	乘，除，取模和取整除
+ -	加法减法
>> <<	右移，左移运算符
&	位 'AND'
^ |	位运算符
<= < > >=	比较运算符
<> == !=	等于运算符
= %= /= //= -= += *= **=	赋值运算符
is is not	身份运算符
in not in	成员运算符
not or and	逻辑运算符

实际使用中，记住如下简单的规则即可，复杂的表达式一定要使用小括号组织。

1. 乘除优先加减
2. 位运算和算术运算 > 比较运算符 > 赋值运算符 > 逻辑运算符