Python 学习笔记 (一) 基本数据类型

本文环境： Python 3.11.3
本文假定读者已了解 Python 基本语法概念，已成功用 Python 打印 “Hello World!”
本文欢迎转载，请注明原作者以及原链接

一. 数值

（1）整型 (int)

a. 对于编程初学者来说，将其理解为数学中整数的概念即可，可正可负，在程序上的表示方法和在数学上的写法一模一样
b. Python 中的整数和其他编程语言不一样，例如Java中有 byte short int long 等用于区分长度和分配占用的内存空间，在Python中，整数一律为 int 且没有长度限制。
c. 特别地，Python中的整数可以用十进制、十六进制、八进制和二进制来表示，在运行时会自动转换为十进制

# 十六进制前缀为 0x ， 由 0-9 和 A-F 的数字和字母组成
>>> print(0x10)
16

# 八进制前缀为 0o ， 由 0-7 的数字组成
>>> print(0o10)
8

# 二进制前缀为 0b ，仅由 0 和 1 组成
>>> print(0b10)
2

（2）浮点数 (float)

a. 对于编程初学者来说，将其理解为数学中小数的概念即可，可正可负
b. Python 中的浮点数为十进制，不能像整型那样使用非十进制表示
c. 浮点数可以表示的范围约 2.2×10^(-308) 到 1.7×10^308 之间，具体范围可以使用 sys.float_info 来获取

>>> sys.float_info
sys.float_info(max=1.7976931348623157e+308, max_exp=1024, max_10_exp=308, min=2.2250738585072014e-308, min_exp=-1021, min_10_exp=-307, dig=15, mant_dig=53, epsilon=2.220446049250313e-16, radix=2, rounds=1)

d. 使用 round(x, d) 函数可以对浮点数进行四舍五入操作，其中 x 为浮点数，d 为保留的位数

>>> round(1.114514, 2)
1.11

（3）布尔值 (boolean)

a. 布尔值就是我们常说的真 (True) 或假 (False)，可以理解为 对 或 错
b. 与其他语言不同的是，Python的布尔值首字母是大写的

>>> 1 == 1.0
True
# 注意，此处 == 意为比较两个值是否相等，此处只是精度不一样，值其实是相等的
>>> 1.0 == 1.1
False

（4）复数 (complex)

Python中复数不经常用，在此仅作为补充知识
a. Python中的复数基本等同于数学中的复数
b. 在Python中，不同于数学使用 a + bi 来表示复数，Python使用 a + bj 来表示复数
c. Python 中的复数，实部和虚部的值均为浮点数

>>> (2 + 10j).real # 输出实部
2.0
>>> (2 + 10j).imag # 输出虚部
10.0

二. 字符串 str

（1）组成

字符串其实就是字符的串，就是把几个字符给串起来，Python中用 '' (引号) 或者 "" (双引号) 包裹起来的字符即为字符串，用三个单引号 (''') 或三个双引号 (""") 包裹起来可以使字符串内容保持原样，忽略掉其中的特殊字符（例如换行等）

# type() 是Python的内置函数，会输出传入对象的类型
>>> type('abc')
<class 'str'>

>>> type("abc")
<class 'str'>

>>> print("""
...   114514""")

      114514

（2）转义

转义转义，转换含义

转义字符	描述
\	在行尾时，续行符
\\	反斜杠 （\）
\'	单引号（'）
\"	双引号（"）
\n	换行
\t	制表符
\v	纵向制表符
\r	回车
\b	退格
\f	换页
\a	提示音
\ooo	八进制数字
\xhh	十六进制数字
\0	空字符

使转义字符不生效的方法：
a. 在字符串前面加一个 r 这样可以使这个字符串不会被转义，忽略掉转义字符

>>> print(r'Welcome to my \rblog!\n')
Welcome to my \rblog!\n

b. 如果想要指定一个转义字符不被转义，可以在其前面加一个 '\'

# 其实再在前面加一个 \,其实也是将表示转义字符开头的 \,给转义成不带特殊含义的反斜杠（\）
>>> print('Welcome to my \\rblog!\\n')
Welcome to my \rblog!\n

（3）常见操作

a. 长度

使用Python内置的 len() 函数，可以获取到字符串的长度

>>> len("halo world!")
11

转义字符实际上只占1个字符，并不是看起来的2个或更多，中文、空格、字母、数字和符号均占1个长度，空字符串（'' 或 ""）的长度为 0

b. 连接

通过加号（+）来连接2个字符串

>>> print("hello" + " " + "world")
hello world

c. 索引

在Python中，对于字符串有2种索引方式：
1. 正向索引（从前向后）：长度为 x 的字符串，索引范围是 0 ~ x-1
2. 反向索引（从后向前）：长度为 x 的字符串，索引范围是 -1 ~ -x
如果要索引字符串，只需要在字符串变量后加上方括号 [ ]，在里面放上索引值即可

>>> string = '人生苦短，我用Python'
>>> print(string[0], string[4])
人 ，
>>> print(string[-10], string[-1])
短 n

如果字符串索引越界了，则会抛出 IndexError 错误：

>>> string = 'python'
>>> string[10]
...
IndexError: string index out of range

d. 切片

切片即为从字符串中分割出子字符串
字符串切片的标准写法是使用2个冒号和3个数字
例：string[1:10:2]
第1个数字：表示切片的起始位置，可省略，如果省略则从第1个字符开始切片（例子中填入1表示从第2个字符开始切片）
第2个数字：表示切片的结束位置，可省略，如果省略则默认为最后一个字符（例子中填入10表示第10个字符）
第3个数字：步长，当步长为1时可以省略不写第二个冒号和步长
注意：字符串切片的索引区间是左闭右开的，例子的范围用数学表示为 [1,10)，即切片不包括结束位置的字符！！

>>> string = 'Python'
>>> string[:5]
'Pytho'

>>> string[::]  # 切出所有字符
'Python'

>>> string[::-1] # 倒序切出所有字符
'nohtyP'

还有一点需要注意的是，在切片时传入的索引越界，是不会像索引的时候抛出 IndexError 错误的

>>> string = 'Python'
>>> string[:10]
'Python'

>>> string[7:]
''

三. 列表 list

列表是Python独有的数据类型，它跟Java和C中的数组有点类似，但是在Python中不需要预先指定数组大小，并且也可以存放多种类型的数据，包括列表

（1）创建

不同的数据项使用逗号 , 来分隔，用方括号 [ ] 将这些数据包裹起来，就形成了一个列表

>>> a = [1, 2.0, (1 + 2j), 'a', "b", [3, 4, 5]]
>>> type(a)
<class 'list'>

如果想要定义一个空的列表，直接输入一对方括号即可

>>> b = []
>>> type(b)
<class 'list'>

（2）操作

a. 长度

和字符串一样，使用Python内置的函数 len() 即可获得列表的长度

>>> a = [1, 2.0, (1 + 2j), 'a', "b", [3, 4, 5]]
>>> len(a)
6

b. 连接

和字符串一样，使用加号（+）即可连接两个列表

>>> a = [1, 2, 3]
>>> b = [4, 5, 6]
>>> a + b
[1, 2, 3, 4, 5, 6]

c. 索引

格式：列表变量名[索引] （索引从0开始）

>>> a = [1, 2.0, (1 + 2j), 'a', "b", [3, 4, 5]]
>>> a[1]
2.0

如果我们需要从取出嵌套列表中的元素，只需要在后面再加上一组方括号即可

# 因为列表索引返回的是列表中对应索引的元素，如果返回的元素恰好也是列表
# 那么 a[5] 就相当于嵌套列表的变量名 
>>> a[5][0]
3

从列表取出数值时，如果传入的索引越界，那么就会抛出 IndexError 错误

>>> a[6]
...
IndexError: list index out of range

和字符串一样，想要取出列表中最后一个元素的时候，可以直接取索引为-1，即返回最后一个元素

>>> a[-1]
[3, 4, 5]

d. 切片

列表的切片逻辑和字符串基本一致，基本用法请参照字符串，本文不再赘述

>>> a = [1, 2, 3, 4, 5, 6]
>>> a[1::2]
[2, 4, 6]

>>> a[1:]
[2, 3, 4, 5, 6]

>>> a[:4]
[1, 2, 3, 4]

e. 复制

像做数学乘法运算一样，将列表的变量名乘以倍数即可，并且会生成一个新列表

>>> a = ['a', 'b', 'c']
>>> a*3
['a', 'b', 'c', 'a', 'b', 'c', 'a', 'b', 'c']

f. 遍历

通过 for 循环的方式来遍历列表中的元素
格式：for 元素 in 列表:

>>> a = [1, 2, 3, [4, 5, 6]]
>>> for i in a:
...    print(i)
1
2
3
[4, 5, 6]

g. 修改元素

列表可变，因此可以修改其元素
通过列表索引可以访问元素，对其赋值可以进行修改

>>> a = [1, 2, 3, [4, 5, 6]]
>>> a[1] = 'Python'
>>> print(a)
[1, 'Python', 3, [4, 5, 6]]

h. 删除元素

一般我们不会主动的去删除一个列表，系统会自动回收
使用 del 列表名，即可手动删除一个列表

>>> a = [1, 2, 3, 4, 5, 6]
>>> del a
>>> print(a)
...
NameError: name 'a' is not defined

i. 判断列表中是否存在某个元素

使用 Python 中的 in 关键词，返回布尔值
格式：元素 in 列表

>>> a = [1, 2, 3, [4, 5, 6]]
>>> 8 in a
False
>>> 1 in a
True

j. 获取最大和最小值

Python 内置的 min() 和 max() 函数可以用于获取列表的最大和最小值

>>> a = [1 ,2 ,3, 4, 5, 6]
>>> min(a)
1
>>> max(a)
6

（3）函数

Python 列表对象中内置了丰富的函数，可以对列表进行增加、删除、修改、查询和排列等操作

方法	描述
list.append(obj)	在列表末尾添加一个元素
list.extend(iterable)	将可迭代对象中的所有元素添加到列表中
list.insert(index, obj)	在指定位置插入一个元素
list.remove(obj)	从列表中删除一个元素
list.pop([index])	删除列表中指定位置的元素，并返回该元素
list.index(obj)	返回列表中第一个与 obj 相等的元素的索引
list.count(obj)	返回列表中 obj 出现的次数
list.sort(key=None, reverse=False)	对列表进行排序，默认升序排序
list.reverse()	反转列表中的元素

a. list.append()

在列表的末尾添加一个元素

>>> a = [1, 2, 3, 4]
>>> a.append(5)
>>> a
[1, 2, 3, 4, 5]

b. list.extend()

将可迭代对象中的所有元素添加到列表中
Python 中的可迭代对象指的是存储了元素的一个容器对象，例如列表、元组、字典、字符串

>>> a = [1, 2, 3, 4, 5]
>>> b = 'abcdefg'
>>> a.extend(b)
>>> a
[1, 2, 3, 4, 5, 'a', 'b', 'c', 'd', 'e', 'f', 'g']

c. list.insert()

在指定位置插入一个元素
例：list.insert(index, obj)
Index 是要插入的位置，Obj指的是要插入的对象

>>> a = [1, 2, 3, 4, 5]
>>> a.insert(1, 6)
>>> a
[1, 6, 2, 3, 4, 5]

d. list.remove()

从列表中删除一个元素
注意：这个方法只会删除在列表中从头开始匹配的第一个元素

>>> a = [1, 1, 2, 3, 4, 5]
>>> a.remove(1)
>>> a
[1, 2, 3, 4, 5]

e. list.pop()

删除列表中指定位置的元素，并返回该元素
注意：需要传入对应元素的索引！

>>> a = [1, 2, 3, 4, 5]
>>> a.pop(4)
5
>>> a
[1, 2, 3, 4]

f. list.index()

返回列表中第一个与 obj 相等的元素的索引，在元素不存在时会抛出 ValueError 异常

>>> a = [1, 2, 3, 4, 5]
>>> a.index(5)
4
>>> a.index(6)
...
ValueError: 6 is not in list

g. list.count()

返回列表中指定元素出现的次数

>>> a = [2, 2, 3, 5, 5, 5, 6,]
>>> a.count(5)
3

h. list.sort()

对列表进行排序，默认情况下排序为升序，即从小到大

>>> a = [4, 1, 6, 2, 8, 10, 0]
>>> a.sort()
>>> a
[0, 1, 2, 4, 6, 8, 10]

可以传入参数 reverse=True 将其变为从大到小

>>> a = [4, 1, 6, 2, 8, 10, 0]
>>> a.sort(reverse=True)
[10, 8, 6, 4, 2, 1, 0]

i. list.reverse()

反转列表中的元素

>>> a = [10, 8, 6, 4, 2, 1, 0]
>>> a.reverse()
>>> a
[0, 1, 2, 4, 6, 8, 10]

四. 元组 Tuple

元组和列表非常相似，它们都可以存储不同类型的对象，但是与列表不同的是，元组在创建后，其便不再能被修改。

（1）创建

如前文所述，列表是用一对方括号 [ ] 将元素包裹起来，并用 逗号 , 来分隔开每个元素
元组也一样，不过需要将方括号换成圆括号 ( )
你也可以使用 tuple() 内置函数来将列表转换成元组

>>> a = (1, 2)
>>> type(a)
<class 'tuple'>

>>> b = [1, 2, 3, [4, 5, 6]]
>>> tuple(b)
(1, 2, 3, [4, 5, 6])

创建包含0个或者1个元素的元组比较特殊，有一些额外的语法规则

# 空元组直接使用一对括号即可
tuple = ()

# 包含1个元素的元组需要在元素后加逗号
tuple2 = (1, )

（2）操作

由于元组和列表有很多共同点，本文在这里使用一个代码例子来简述元组的操作

tuple = ( 'abcd', [1, 2, 3], 2.23, 'string', 70.2  )
tinytuple = (123, 'abc')

print(tuple)          # 输出完整元组
print(tuple[0])        # 输出元组的第一个元素
print(tuple[1:3])       # 输出从第二个元素开始到第三个元素
print(tuple[2:])        # 输出从第三个元素开始的所有元素
print(tinytuple * 2)     # 输出两次元组
print(tuple + tinytuple)   # 连接元组

以上代码执行后的输出为：

('abcd', [1, 2, 3], 2.23, 'string', 70.2)
abcd
([1, 2, 3], 2.23)
(2.23, 'string', 70.2)
(123, 'abc', 123, 'abc')
('abcd', [1, 2, 3], 2.23, 'string', 70.2, 123, 'abc')

如前文所述，元组内的元素是不支持修改的，如果尝试修改，则会抛出 TypeError 错误

>>> a = (1, 2, 3, 4)
>>> a[3]
4
>>> a[3] = 1
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

但是，元组内的元素不支持修改，不代表其不能包含可变的对象，例如列表

>>> a = (1, 2, 3, [4])
>>> a[3].append(1)
>>> a
(1, 2, 3, [4, 1])

（3）方法

由于元组对象内的元素不可变，因此“增删改查”中的“增删改”对元组无效，因此元组能用到的函数非常有限，基本

上都是Python内置的函数

a. len()

此函数用于获取元组中元素的数量

>>> fruits = ('apple', 'banana', 'orange')
>>> len(fruits)
3

b. tuple.count()

此函数用于统计元组中指定元素的出现次数

>>> fruits = ('apple', 'banana', 'orange', 'apple')
>>> fruits.count('apple')
2

c. tuple.index()

返回元组中对应元素的下标
当元组中有多个符合条件的元素，返回第一个出现的元素

>>> fruits = ('apple', 'banana', 'orange', 'apple')
>>> fruits.index('apple')
0

五. 集合 Set

集合 （Set）是无序的不重复元素序列
它像列表和元组一样，可以存放任何类型的数据，包括前文所提到的数值、字符串、列表和下文将要介绍的字典。由于集合中的元素不会重复，因此可以进行交集 / 并集 / 差集等常见的集合操作

（1）创建

a. 空集合

不像前文提到的字符串/元组/数组可以使用特定的符号创建空对象
要创建空集合必须使用 set() 函数

>>> a = set()
>>> a
set()

b. 非空集合

如果要创建非空集合，可以使用 { } 花括号将所需的元素包裹起来，元素间使用 , 隔开

>>> type({1,2,3})
<class 'set'>

同时，也可以使用 Set() 函数来从可迭代对象创建集合
可迭代对象简而言之，就是可以使用 for item in items 来遍历内部元素的对象
想了解更多关于可迭代对象等更深入的内容，可以参见 这篇 CSDN博客

>>> set("Hello World!")
{'e', 'o', '!', ' ', 'd', 'l', 'W', 'H', 'r'}

>>> set(['a', 'b', 'c', 1, 2, 3])
{1, 2, 3, 'a', 'c', 'b'}

（2）操作

a. 添加

使用 add() 方法来向集合内添加一个元素，使用 update() 来从可迭代对象向集合添加多个元素

>>> a = set([1, 2, 3])
>>> a.add(4)
{1, 2, 3, 4}

>>> a.update([5, 6, 7])
{1, 2, 3, 4, 5, 6, 7}

b. 删除

可以使用 remove() 来从集合中移除一个元素，当元素不存在时会抛出 KeyError 异常

>>> a = set([1, 2 ,3])
>>> a.remove(4)
Traceback (most recent call last):
    ...
KeyError: 4

使用 discard() 则可以安全的从集合中移除元素，当元素不存在时不会抛出异常

>>> a = set([1, 2, 3])
>>> a.discard(4)
{1, 2, 3}

c. 清空

使用 clear() 方法可以清空集合内所有元素

>>> a = set([1, 2, 3])
>>> a.clear()
set()

d. 更新

前文的添加提到可以使用 update() 函数从可迭代对象向集合添加多个元素
可迭代对象也包含了集合，因此可以将一个集合的元素添加到另外一个集合中

>>> a = set([1, 2, 3])
>>> b = set([3, 4, 5])
>>> a.update(b)
{1, 2, 3, 4, 5}

如本段刚开始提到，集合中的元素必须是唯一的
使用 update() 向集合添加元素时，如果有重复的元素会被直接忽略掉

（3）运算

集合最特殊的一点是，支持并集、交集和差集等运算，这与我们高中数学中集合的概念基本一样
并且可以直接在代码中使用运算符进行运算，等效于使用对应函数
例如：

运算	运算符	对应方法
并集	|	union()
交集	&	intersection()
差集	-	difference()
对称差集	^	symmetric_difference()

本部分所有小节将假设有如下 a 和 b 这两个集合：

>>> a = {1, 2, 3, 4}
>>> b = {3, 4, 5, 6}

a. 并集 Union

并集使用 | 运算符，或者集合对象内置的 union() 方法
如数学中的并集，会返回两个集合中的所有唯一元素的集合

>>> a | b
{1, 2, 3, 4, 5, 6}

>>> a.union(b)
{1, 2, 3, 4, 5, 6}

b. 交集 Intersection

交集使用 & 运算符，或者集合对象内置的 intersection() 方法
如数学中的交集，会返回两个集合中的有相同元素的集合

>>> a & b
{3, 4}
>>> a.intersection(b)
{3, 4}

c. 差集 Difference

差集使用 - 运算符，或者集合对象内置的 difference() 方法
如数学中的差集，返回在第一个集合中但不在第二个集合中的元素组成的集合

>>> a - b
{1, 2}
>>> a.difference(b)
{1, 2}

d. 对称差集 Symmetric Difference

对称差集使用 ^ 运算符，或者集合对象内置的 symmetric_difference() 方法
返回由两个集合中不重复的元素组成的集合，即取两个集合中没有重复的元素

>>> a ^ b
{1, 2, 5, 6}
>>> a.symmetric_difference(b)
{1, 2, 5, 6}

六. 字典 Dictionary

重磅的东西总是要放在最后，让我们请Python最重磅（至少我个人这么认为）的内置对象 字典 登场！
字典是一种可变容器模型，用于存储键值对，其基本结构和 JSON 很类似（或者说）
这是一个基本的字典对象：

>>> a = {'key1': 'value1', 'key2': 114.514}
>>> type(a)
<class 'dict'>

（1）基本结构

每个键值对由冒号 : 分隔，不同键值对之间用逗号 , 分隔。整个字典包含在花括号 {} 中。
键必须由不可变对象组成，例如字符串、数字和元组等
而值则可以使任何数据类型，包括字典和自定义对象
下面这个字典符合以上结构要求：

>>> a = {1: 'value1', '2': 2.0, (3,): (1 + 1.0j), (4 + 4.0j): [1, 2, 3]}
>>> type(a)
<class 'dict'>

（2）创建

a. 空字典

只需要一对花括号 { } 即可创建空字典对象，或者使用 dict() 函数

>>> a = {}
>>> type(a)
<class 'dict'>

>>> b = dict()
>>> type(b)
<class 'dict'>

b. 赋值

通过赋值创建字典需要严格遵守上一小节的字典结构

>>> a = {'a': 'a', 1: 1, "newDict": {'hello': "world"}}
>>> type(a)
<class 'dict'>

c. 字典推导式

字典推导式的基本结构如下，其中 [if 条件表达式] 是可选的
{表达式 for 迭代变量 in 可迭代对象 [if 条件表达式]}
观察其基本结构，能发现这个和 Python 中 for 循环存在一定关联
当去除掉 [if 条件表达式] 时，其基本上就是一个 for 循环，字典推导式与其最大的不同是，其最终会将循环过程中，计算表达式得到的一系列值组成一个字典。

>>> key_list = ['a', 'b', 'c', 'd']
>>> value_list = [1, 2, 3, 4]
>>> {key: value for key, value in zip(key_list, value_list)}
{'a': 1, 'b': 2, 'c': 3, 'd': 4}

Python 中不仅字典有推导式，列表、元组和集合也都有推导式，关于这部分的学习笔记后面会发布出来

d. 关键字参数

使用 dict()函数，传入 key1=value1, key2=value2 等变量
即 dict(key1=value1, key2=value2)
关键字参数可以快速安全的创建一个字典对象，而无需像赋值那样关心结构是否标准
但是有一点要注意，在这种情况下key的值就必须是字符串

>>> a = dict(key1={1, 2}, key2=1.0)
{'key1': {1: 2}, 'key2': 1.0}

e. 使用 dict() 和 zip()

Python 内置的 zip() 函数，用于将可迭代对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的zip对象，如果需要转换成列表，则需要使用 list() 来转换
不过 dict() 函数也接受 zip 对象的输入，我们可以直接这样创建对象：

>>> key_list = ['a', 'b', 'c', 'd']
>>> value_list = [1, 2, 3, 4]
>>> dict(zip(key_list, value_list))
{'a': 1, 'b': 2, 'c': 3, 'd': 4}

f. 直接使用 dict()

说实话，这么写真的有点多次一举，我刚发现还能这么写的时候也是惊了
dict() 函数可以直接传入字典对象来创建字典

>>> dict({"name": "Okita_Soji", "id": 68, "cost": 16, "alter_name": "sakura_saber"})
{'name': 'Okita_Souji', 'id': 68, 'cost': 16, 'alter_name': 'sakura_saber'}

g. 使用 dict.fromkeys()

dict.fromkeys() 可以传入1个可迭代对象和1个对象来创建字典
当仅传入一个可迭代对象时，会将其作为 key 使用，value 则为 None

>>> dict.fromkeys(['alice', 'john', 'james', 'smith'])
{'alice': None, 'john': None, 'james': None, 'smith': None}

当传入1个可迭代对象和1个对象时，后面那个对象会被作为所有 value 的默认值

>>> dict.fromkeys(['alice', 'john', 'james', 'smith'], 1)
{'alice': 1, 'john': 1, 'james': 1, 'smith': 1}

（3）操作

a. 增加

增加新的键值对到字典中有2种方法：

（a）直接赋值

格式：字典变量[key] = 值

>>> dict1 = {"name": "alice", "age": 18}
>>> dict1['gender'] = 'female'
{'name': 'alice', 'age': 18, 'gender': 'female'}

如果对应key在原字典中已经存在，则会重新对该key进行赋值

（b）使用 dict.update()

这个一般用于对字典的拼接，也可以用于向一个字典批量添加键值对

>>> dict1 = {"name": "alice", "age": 12}
>>> dict1.update({"gender": "female", "country": "US", "grade": "elementary_6"})
{'name': 'alice', 'age': 12, 'gender': 'female', 'country': 'US', 'grade': 'elementary_6'}

如果只想添加一个键值对，也可以这么写

>>> dict1 = {"name": "alice", "age": 18}
>>> dict1.update(gender='female')
>>> dict1
{'name': 'alice', 'age': 18, 'gender': 'female'}

但如果这么写，也会受到上一小节 d.关键词参数 同样的限制，并且同上如果某个key已经在原字典中，则会对该key重新赋值

b. 删除

若要删除字典中指定的键值对，有以下2种方法

（a）del 关键字

格式：del 字典变量[key]

>>> dict1 = {"name": "alice", "age": 12}
>>> del dict1['age']
>>> dict1
{'name': 'alice'}

（b）dict.pop()

dict.pop() 会从字典中删除指定键对应的键值对，并会将其返回，可以理解为字典中取出对应键值对

>>> dict1 = {"name": "alice", "age": 12}
>>> dict1.pop("age")
12
>>> dict1
{'name': 'alice'}

c. 清空

和集合一样，字典也可以使用 dict.clear() 来清除字典内的所有键值对

>>> dict1 = {"name": "alice", "age": 12}
>>> dict1.clear()
>>> dict1
{}

d. 取出最后一个键值对

注意：此方法在 Python 3.11.3 中是取出最后一个键值对，仅供参考
与其他对象不同的是，字典对象除了 dict.pop() 之外也有 dict.popitem() 方法，效果是从字典中取出最后一个键值对，并返回由其构成的元组

>>> dict1 = {"name": "alice", "age": 12}
>>> dict1.popitem()
('age', 12)
>>> dict1
{'name': 'alice'}

e. 修改

请见本节的 a. 增加，效果一样

f. 查询

查询字典内所有或特定的键值对有五种办法

（a）用键查询值

格式：字典变量[key]
不过需要注意的是，使用这种方法查询值的时候，如果传入的键不存在，则会抛出 KeyError 错误

>>> dict1 = {"name": "alice", "age": 12}
>>> dict1['name']
'alice'

>>> dict1['gender']
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'gender'

（b）dict.get(key)

实践上更推荐使用本方法来查询值，若查询的值不存在时默认会返回None，不会报错，若有需要也可也自定义返回内容，只需要在传入key的时候再传入一个对象作为默认返回值即可

>>> dict1 = {"name": "alice", "age": 12}
>>> dict1.get('name')
'alice'
>>> dict1.get('gender')
None
>>> dict1.get('gender', 'unset')
'unset'

（c）dict.keys()

获取字典中所有键值对的键名，返回一个 dict_keys 对象

>>> dict1 = {'name': 'alice', 'age': 12, 'gender': 'female', 'country': 'US', 'grade': 'elementary_6'}
>>> dict1.keys()
dict_keys(['name', 'age', 'gender', 'country', 'grade'])

（d）dict.values()

同上，只不过获取的是所有键值对的值，返回一个 dict_values 对象

>>> dict1 = {'name': 'alice', 'age': 12, 'gender': 'female', 'country': 'US', 'grade': 'elementary_6'}
>>> dict1.values()
dict_values(['alice', 12, 'female', 'US', 'elementary_6'])

（e）dict.items()

输出字典内的所有键值对，并将每个键值对打包成元组封装在一个 dict_items 对象返回

>>> dict1 = {'name': 'alice', 'age': 12, 'gender': 'female', 'country': 'US', 'grade': 'elementary_6'}
>>> dict1.items()
dict_items([('name', 'alice'), ('age', 12), ('gender', 'female'), ('country', 'US'), ('grade', 'elementary_6')])

g. 遍历

由于字典对象是可迭代对象，这意味着可以使用 for 循环来直接遍历字典内所有元素，但默认遍历只会遍历字典内每一个键

>>> dict1 = {'name': 'alice', 'age': 12, 'gender': 'female', 'country': 'US', 'grade': 'elementary_6'}
>>> for item in dict1:
...     print(item)
name
age
gender
country
grade

这个时候，我们可以使用上一小节所介绍的 keys() values() 和 items() 来指定我们想要遍历的内容

# 篇幅限制，此处就只用 items() 举例
>>> dict1 = {'name': 'alice', 'age': 12, 'gender': 'female', 'country': 'US', 'grade': 'elementary_6'}
>>> for key, value in dict1.items():
...     print(key, value)
name alice
age 12
gender female
country US
grade elementary_6

如果你不想使用上面那些内置函数而你又想遍历键值对，那么你也可以这么写：

>>> dict1 = {'name': 'alice', 'age': 12, 'gender': 'female', 'country': 'US', 'grade': 'elementary_6'}
>>> for item in dict1:
...     print(item, dict1[item])
name alice
age 12
gender female
country US
grade elementary_6

七. 字节 Bytes

此部分本文仅做简单介绍
在 Python 中，Bytes 类型是不可变的二进制序列（Byte sequence）
与本文之前介绍的字符串类型不同，Bytes 类型的元素是整数值，范围是 0 ~ 255 （2^8）
Bytes 类型主要用于处理二进制数据，如图片/音频/视频等，也经常被网络编程用来传输二进制数据

若要创建 Bytes 对象，最常见最简单的就是在字符串前面加上 ‘b’ 前缀

>>> type(b"Hello World")
<class 'bytes'>

你也可以使用 bytes() 函数来创建对象，但是你就必须指定编码格式，否则会抛出 TypeError 错误

>>> bytes("Hello World")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: string argument without an encoding

>>> bytes("Hello World", encoding="utf-8")
b'Hello World'

>>> bytes("Hello World", encoding="gbk")
b'Hello World'

英文名	中文名	简介
ASCII	美国信息交换标准代码	最早的计算机编码系统 仅支持英文26个大小写字母、常见符号和控制符
GBK	《汉字内码扩展规范》	基于包含全部中文字符，基于GB2312扩展而来 通用性比UTF-8较差
GB18030	《信息交换用汉字编码字符集》	容错率较低，错一个字节就有可能影响后面的一串字符 编码效率较高，每个字符只需2个字节
UTF-8		目前最广泛使用的计算机编码系统 容错性较高，任意错一个字节都不会影响其他字符 编码效率较低，一个中文字符需要 3-4 字节 包含几乎所有语言的字符
UTF-16		请见 百度百科

Bytes 对象和字符串一样，也都支持切片、拼接、查找和替换等操作，本文在此不再赘述，但需要注意的是，Bytes 类型是不可变的，因此每当对其进行以上操作的时候，都会创建一个新的 Bytes 对象

八. 本文结语

希望你在完整看完这篇文章后，能够对Python内的一些内置数据对象有基本的了解，如果这篇文章能够激发你学习Python乃至整个计算机编程世界的兴趣，那就再好不过了。Python 作为一门快速上手的语言，入门的门槛也是相当的低，代码如果写的优雅点几乎可以当作自然语言来阅读和理解了，但是也请不要止步于此，除了Python，外面还有更广阔的世界等着你探索，有接近计算机底层的 C语言，也有不那么接近的 C++语言，还有效率奇高的 Golang，也有压缩成瓶子的 Java，等等等....

希望在下一篇文章还能见到你，再见！