py003_python的容器类型-优快云博客

本文链接：https://blog.youkuaiyun.com/euler_8s/article/details/148831200

1. 容器类型

**概述：**容器类型就是可以保存多个数据或变量的数据类型。
作用：
- 减少变量的定义。例如，我们要保存一个学生的所有信息，使用容器类型只需要一个变量即可。
- 容器类型中的元素可以使用for循环依次遍历获取。
- 容器类型有自己的增删改查方法，便于使用。
- 容器类型可以提升开发和存储效率。
分类：
- 字符串（str）：用于存储文本数据。
- 列表（list）：可以存储任意类型的数据，并且数据类型可以混合存储。
- 元组（tuple）：与列表类似，但元组中的元素不可修改。
- 字典（dict）：通过键值对的方式存储数据，键具有唯一性。
- 集合（set）：存储无序且唯一的数据。

2. 字符串

2.1 字符串定义

**概述：**字符串就是多个字符的组合，将多个字符放入一个容器中就形成了一个字符串，字符串类型是容器类型，可以迭代。
定义方式：
- 一对单引号
- 一对双引号
- 三对单引号
- 三对双引号
注意：
- 在python中单双引号不敏感，但是尽可能的保证统一，而且不能单双引号混用，例如：'这样是错误的"。
- 三对引号定义的字符串会保留格式效果，比如字符串内如果有换行，打印时换行依然存在。
**字符串定义方式嵌套：**不同的字符串定义方式可以嵌套使用，方便字符串的处理和数据的存储。
- 当需要在字符串中包含单引号时，可以使用双引号来定义字符串。
- 当需要在字符串中包含双引号时，可以使用单引号来定义字符串。
- 如果字符串中同时包含单引号和双引号，可以使用三引号来定义字符串。

代码示例：

str1 = 'hello'
str2 = "world"
str3 = '''hello python'''
str4 = """对酒当歌"""
print(type(str1))  # <class 'str'>
print(type(str2))  # <class 'str'>
print(type(str3))  # <class 'str'>
print(type(str4))  # <class 'str'>

str5 = """
天上白玉京，十二楼五城。
仙人抚我顶，结发受长生。
"""
print(str5)
"""
打印效果，前引号后和后引号前的换行也保留了

天上白玉京，十二楼五城。
仙人抚我顶，结发受长生。

"""

# 字符串嵌套
# 打印 I'm euler
# print('I'm euler')    # SyntaxError: unterminated string literal
print("I'm euler")  # 可以通过字符串嵌套的方式，解决引号的匹配问题
print('I\'m euler')  # 也可以通过转义字符解决这个问题

# 打印：子曰："I'm happy"
print('''子曰："I'm happy"''')

2.2 字符串下标

**概述：**下标就是指元素在字符串中的索引，每一个索引对应一个唯一的元素。字符串的下标【索引】都是从0开始的连续不间断的整数
**格式：**字符串变量[索引] # 根据索引获取字符串中指定位置的元素。
分类：
- 正数索引：从左到右依次递增，取值范围是[0, n-1]，其中n为字符串长度。
- 负数索引：从-1开始从右向左依次递减，取值范围是[-n,-1]。
注意：
- 字符串的最大正数索引为：字符串的长度 - 1，如果超过这个范围会报错。
- 超过最小负数索引依然会报错。
- 字符串中左侧字符的索引一定小于右侧的索引。
- 我们一般都是使用正数索引，当需要取字符串中的最后几个元素时，使用负数索引。

代码示例：

# 字符串的索引
str1 = '今日长缨在手，何时缚住苍龙'
# 找到字符串中的 长
print(str1[2])  # 长
# 找到字符串中的 龙
print(str1[12])  # 龙
print(str1[-1])  # 龙
# print(str1[15])  # IndexError: string index out of range
# print(str1[-15])  # IndexError: string index out of range

str2 = 'abcdefg'
print(str2[0:3:1])  # abc
print(str2[2:27:1])  # cdefg
print(str2[20:26:1])  # 空字符串
print(str2)  # abcdef 切片不改变原字符串
print(str2[::-1])  # gfedcba 负数步长一般用于字符串的逆转
print(str2[0:3:-1])  # 空字符串，使用负数步长时，如果起始位置<结束位置，那么返回空字符串

# 当步长为正数
str3 = '数风流人物，还看今朝'
print(str3[0:5:1])  # 数风流人物
print(str3[:5:1])  # 数风流人物 省略起始位置
print(str3[:5:])  # 数风流人物 省略步长
print(str3[:5])  # 数风流人物 省略步长
print(str3[6:10:1])  # 还看今朝
print(str3[6::1])  # 还看今朝 省略终止位置
print(str3[6:])  # 还看今朝 省略步长
print(str3[:])  # 相当于复制一个字符串，不能省略 :

# 当步长为负数
print(str3[-1:-5:-1])  # 朝今看还
print(str3[:-5:-1])  # 朝今看还 省略起始位置
print(str3[::-1])  # 朝今看还，物人流风数 省略起始位置、结束位置

2.3 字符串切片

**概述：**字符串切片就是按照规则获取字符串中一部分元素的方法。
**格式：**字符串变量[起始位置: 终止位置: 步长]
- 起始位置：切片开始位置的索引（包含）。
- 终止位置：切片结束位置的索引（不包含）。
- 步长：获取数据的间隔（后一个索引减去前一个索引）。
- 当步长为负数时，获取到的数据的顺序是从右到左，但是要注意起始位置和终止位置，如果起始位置小于终止位置，那么从右往左取值时是没有数据的。因为从起始位置往左走是没有从起始位置到终止位置的元素的（这部分元素在起始位置的右边，但是取值的时候只能往左走）。
注意：
- 字符串的切片使用的是:，range函数使用的时,使用的时候如果搞混了会报错。
- 如果切片的范围超出索引范围不会报错：
  - 只保留能够获取到的数据。
  - 如果起始位置超了会取到空字符串（切片范围不存在）。
  - 如果只有结束范围超了会取到从起始位置之后的字符串。
- 切片会产生新的字符串，原字符串不发生改变。
- 负数步长一般用于字符串的逆转。
字符串切片的省略：
- 当步长为正时：
  - 可以省略起始位置：省略后默认从字符串开始位置开始切片。
  - 可以省略终止位置：省略后默认到字符串结束位置结束切片。
  - 可以省略步长：省略后默认步长为1，如果省略步长可以省略步长前的:。
- 当步长为负时：不能省略步长
  - 可以省略起始位置：省略后默认从字符串结束位置开始切片。
  - 可以省略终止位置：省略后默认到字符串开始位置结束切片。

2.4 字符串函数

字符串find()方法：find(self, sub, __start, __end)
- 功能：查找特定字符或子串在字符串中的位置，如果找到则返回子串首字符所在的索引，否则返回-1。
- 参数介绍：
  - sub：要查找的字符或字符串
  - __start：查找的起始位置索引
  - __end：查找的终止位置索引
- 注意：
  - 起始位置和终止位置可以省略，省略后默认在整个字符串中查找。
  - 如果指定起始位置和终止位置，则该范围是一个左闭右开区间。
  - 如果要查找的字符或字符串不存在，则返回-1，如果要根据返回值获取数据内容，那么一定要判断返回值是否为-1。
  - find如果找到对应字符串，则返回的是从左到右，第一个匹配到的字符串索引。
字符串index()方法：index(self, sub, __start, __end)
- 功能：查找特定字符或子串在字符串中的位置，如果找到则返回子串首字符所在的索引，否则报错。
- 参数介绍：
  - sub：要查找的字符或字符串
  - __start：查找的起始位置索引
  - __end：查找的终止位置索引
- 注意：
  - 起始位置和终止位置可以省略，省略后默认在整个字符串中查找。
  - 如果指定起始位置和终止位置，则该范围是一个左闭右开区间。
字符串replace()方法：replace(self, __old, __new, __count)
- 功能：将字符串中的子字符串替换为新的字符内容，原始数据不会发生改变。
- 参数介绍：
  - __old：旧值
  - __new：新值
  - __count：替换次数
- 注意：
  - __count可以省略，默认替换所有。
  - 如果__count值大于所有的子串个数，不会报错，会替换所以目标子串。
  - 如果要替换的目标子串在原字符串中不存在，不会报错，也不会发生改变。
字符串split()方法：split(self, sep, maxsplit)
- 功能：根据指定的字符，将字符串拆分为多个子字符串，放置在一个列表中返回。
- 参数介绍：
  - sep：拆分字符串时依照的分隔符
  - maxsplit：拆分字符串时最大的拆分次数，最多将字符串拆分为maxsplit+1份
- 注意：
  - maxsplit可以省略，省略时默认全部拆分。
  - 如果split()中不传传参数，默认按照空白拆分，空白包括：空格、制表符、换行符。
  - 按照哪个字符或字符串进行拆分，那么该字符或字符串将会消失。
其他常用的字符串方法：
- count：用于查询字符串中有几个指定子字符串，同样可以约束查询范围
- len：用来查询字符串中有多少个元素，空格、换行符等都会计算元素个数
- strip：去除字符串左右两侧的指定字符，中间的字符不去除。如果没有指定字符，默认去除左右两侧的空白
- jion：根据指定的字符将列表中的字符串合并为一个字符串
- lower：转化为全小写
- upper：转化为全大写
- title：将每个单词的首字母大写，判断是否为一个单词的依据：只要是非字母数据就是分隔符
- capitalize()：字符串首字母大写
- startwith()：是否以某个字符串开始，返回值为布尔类型，严格区分大小写
- endwith()：是否以某个字符串结尾
- isdigit()：判断字符串中是否为纯数字，字符串中如果是浮点型则无法判断

代码示例：

# find()
str1 = 'hello world'
print(str1.find('e'))  # 1
print(str1.find('o'))  # 4
print(str1.find('world'))  # 6
print(str1.find('p'))  # -1

# index()
print(str1.index('l'))  # 2
# print(str1.index('p'))  # ValueError: substring not found

# replace
str2 = 'hello python and hello ai and hello world'
# 将所有的 and 替换为 &，如果没有给count值，默认全部替换
print(str2.replace('and', '&'))
# 将从左到右的第一个 and 替换为 ,
print(str2.replace('and', ',', 1))
# 如果给的count值大于所有的子串个数则全部替换
print(str2.replace('and', '&', 10))
# 如果要替换的字符串在原字符串中不存在时，不报错，不发生任何变化
print(str2.replace('￥', '$'))

# split
str3 = 'hello python and world'
# 按照空格将字符串拆分为单词放在列表中返回
str3_list = str3.split(' ')
print(str3_list)  # ['hello', 'python', 'and', 'world']
print(type(str3_list))  # <class 'list'>
# 设置最大拆分次数为2，则此时拆分为3份，并且是从左到右依次拆分的
str3_list = str3.split(' ', 2)
print(str3_list)  # ['hello', 'python', 'and world']
str4 = 'hello python\tc\nand world'
print(str4.split())  # ['hello', 'python', 'c', 'and', 'world']
str5 = 'apple and banana'
print(str5.split('a'))  # ['', 'pple ', 'nd b', 'n', 'n', '']

print(str5.count('a'))  # 5
print(len(str5))  # 16
str6 = '  strip   '
print(str6.strip(' '))  # strip
str_list = ['hello', 'python', 'and', 'world']
print(' '.join(str_list))  # hello python and world

3. 列表

3.1 列表定义

**概述：**一次性存储多个数据，保存在同一个变量中，是一个容器类型。
**格式：**变量=[元素1, 元素2, 元素3 …]
注意：
- python中列表类型中可以存储任意类型数据，而且数据类型可以混合存储。
- 列表同样是根据索引值获取元素，方法和字符串相同。

代码示例：

list_num = [1, 2, 3, 4, 5]
print(list_num)
print(type(list_num))  # <class 'list'>

list_str = ['hello', 'python', 'and', 'world']
print(list_str)
print(type(list_str))

list1 = [95, 27, True, 'ufo', [1, 2, 3]]
print(list1)

# 创建一个空列表
empty_list = []
print(empty_list)
print(type(empty_list))  # <class 'list'>
empty_list = list()  # 效果同上

list2 = ['a', 'b', 'c']
print(list2[1])  # b
print(list2[-2])  # b

3.2 列表遍历

**概述：**在实际开发中，列表一般都会存储大量的元素，我们无法记住每一个元素的索引，需要通过遍历列表来获取列表中的元素。

代码示例：

# 列表的遍历
list1 = [1, 3, 5, 7, 11, 13]
# 我们一般使用for循环遍历每一个元素
for num in list1:
    print(num)
# 如果要获取列表中的每一个元素及其索引，可以使用enumerate()
for i, num in enumerate(list1):
    print(i, num)

3.3 列表的增操作

**概述：**向列表中增加元素
方法：
- append()：在列表的末尾增加指定元素
  - 使用格式：列表对象.append(数据)
  - append()方法是向列表原数据中增加一个元素，没有产生新的列表
  - 无论在append()括号中填写了基础类型还是容器类型，最终都是当做一个元素添加到列表末尾
- extend()：在列表的末尾扩展一个容器类型的数据，就是将容器内的每一个元素依次追加到列表末尾
  - 使用格式：列表对象.extend(数据)
  - extend()必须传入可迭代数据（容器类型），否则报错
  - 传入的容器类型只有一个元素甚至没有元素都可以，但是不能是非容器类型
- insert()：在列表的指定索引位置增加一个指定元素
  - 使用格式：列表对象.insert(索引, 元素)
  - insert()在指定索引处插入元素会导致其他元素依次后移一位
  - 如果指定的索引大于列表的长度，则会将数据加入到列表末尾

代码示例：

# 列表的增操作
list1 = [1, 3, 5, 7, 11, 13]
print(list1)
list1.append(17)
print(list1)  # [1, 3, 5, 7, 11, 13, 17]

# list1.extend(19)  # TypeError: 'int' object is not iterable
list1.extend([19, 23])
print(list1)  # [1, 3, 5, 7, 11, 13, 17, 19, 23]
list1.insert(1, 2)
print(list1)  # [1, 2, 3, 5, 7, 11, 13, 17, 19, 23]

3.4 列表的删操作

**概述：**删除列表中的元素
方法：
- remove()：根据元素的值删除元素
  - 格式：列表对象.remove(元素)
  - 使用remove()删除元素时，不会产生新列表，而是在原始列表上修改数据
  - 当出现多个相同元素时，只能删除从左到右第一个元素，而不是全部删除
  - 如果要删除的元素不存在，则报错
- pop()：根据索引值删除指定位置的元素
  - 格式：列表对象.pop(索引)
  - 使用pop()删除元素时，会返回被删除的元素值
  - 如果索引值超过列表索引的最大值和最小值，则报错
- clear()：清空列表，此时列表为空列表
  - 格式：列表对象.clear()
  - 与把列表变量赋值为[]不等价
**注意：**删除列表中的中间位置的元素时，后续元素的索引会发生改变。

代码示例：

# remove() 根据元素删除
list1 = [1, 2, 3, 1, 2, 3, 4, 5, 6]
# print(list1.remove(5))  # None
list1.remove(5)
print(list1)  # [1, 2, 3, 1, 2, 3, 4, 6]
list1.remove(3)
print(list1)  # [1, 2, 1, 2, 3, 4, 6]
# list1.remove(9)  # ValueError: list.remove(x): x not in list

# pop() 根据元素索引删除元素
list2 = [1, 2, 3, 5, 7, 9]
pop_value = list2.pop(3)
print(list2)  # [1, 2, 3, 7, 9]
print(pop_value)  # 5
# list2.pop(9)  # IndexError: pop index out of range

# clear() 清空列表
list3 = ['python', 'c', 'java']
list4 = list3
print(list3)  # ['python', 'c', 'java']
print(list4)  # ['python', 'c', 'java']
# list3.clear()  # 无返回值
# print(list3)  # []
# print(list4)  # []
list3 = []
print(list3)  # []
print(list4)  # ['python', 'c', 'java']

3.5 列表的改操作

**概述：**修改列表中的元素值
**方法：**根据列表的索引对元素进行修改，格式：列表对象[索引] = 新值
**注意：**要修改位置的索引必须存在，否则报错

代码示例：

# 列表的修改
list1 = ['洪七公', '黄药师', '段智兴']
list1[2] = '一灯大师'
print(list1)  # ['洪七公', '黄药师', '一灯大师']
# list1[3] = '欧阳锋'  # IndexError: list assignment index out of range

3.6 列表的查操作

**概述：**查询列表中的元素
方法：
- 直接使用索引获取元素
- index()：查询指定元素出现的索引值
  - 如果查询的元素不存在，则报错
  - 如果列表中存在多个元素，只返回从左到右第一个元素的索引值
- ount()：查询指定元素在列表中出现的次数
- in、not in：判断元素是否在列表中，返回布尔类型
- list中不存在find方法

代码示例：

# 列表的查操作
list1 = ['python', 'java', 'c', 'cpp', 'python']
print(list1[0])  # python
print(list1[1])  # java
print(list1[-1])  # cpp

# index
print(list1.index('c'))  # 2
# print(list1.index('go'))  # ValueError: 'go' is not in list
print(list1.index('python'))  # 1
# count
print(list1.count('python'))  # 2
print(list1.count('go'))  # 0

# in、not in
print('python' in list1)  # True
print('python' not in list1)  # False

3.7 列表的反转

**概述：**就是把列表元素逆转
方法：
- 使用切片的方法得到一个新列表，格式：列表对象[::-1]
- reverse()：在原始列表上进行修改，不会产生新列表，格式：列表对象.reverse()

代码示例：

# 列表的反转
list1 = ['乔峰', '虚竹', '段誉']
print(list1[::-1])  # ['段誉', '虚竹', '乔峰']
# print(list1.reverse())  # None
list1.reverse()
print(list1)  # ['段誉', '虚竹', '乔峰']

3.8 列表的排序

**概述：**对列表的元素值进行有序排列
方法：
- sort()：在原始列表上进行修改，不会产生新的列表
  - 格式：列表对象.sort()
  - 默认进行升序排序，即从小到大排序
  - 如果要进行降序排序，使用：列表对象.sort(reverse=True)

代码示例：

# 列表的排序
list1 = [1, 2, 5, 0, 7, 3]
# print(list1.sort())  # None
list1.sort()
print(list1)  # [0, 1, 2, 3, 5, 7]
list1.sort(reverse=True)
print(list1)  # [7, 5, 3, 2, 1, 0]

3.9 列表的推导式

**概述：**列表推导式是按照一定的规则，快速生成一个列表的方法
格式：
- 变量 = [要插入列表中的数据 for 临时变量 in 容器]
- 变量 = [要插入列表中的数据 for 临时变量 in 容器 if 条件]

代码示例：

# 列表的推导式
# 创建 一个 元素为 0-9 的列表
list1 = [i for i in range(10)]
print(list1)  # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# 创建 一个 元素为 0-9 中的偶数的列表
list2 = [i for i in range(10) if i % 2 == 0]
print(list2)  # [0, 2, 4, 6, 8]

4. 元组

元组的定义：

概述：元组的操作方式和列表基本相同，但是由于元组不可修改的特性。所以元组的操作方式中没有增删改，只有查询操作。
格式：变量 = (元素1, 元素2, ...)，创建元组时，元组的最外层括号可以省略
创建空元组：变量 = ()或变量 = tuple()
定义一个单元素元组的方法：变量 = (1,)

代码示例：

tuple1 = (1, 2, 3, 4, 5)
print(tuple1)  # (1, 2, 3, 4, 5)
print(type(tuple1))  # <class 'tuple'>

# 创建空元组
tuple2 = ()
print(tuple2)  # ()
print(type(tuple2))  # <class 'tuple'>

tuple3 = tuple()
print(tuple3)  # ()
print(type(tuple3))  # <class 'tuple'>

# 定义一个单元素元组
tuple4 = (1)  # 当括号内没有逗号时，认为括号是用于提升运算优先级的
print(tuple4)  # 1
print(type(tuple4))  # <class 'int'>

tuple5 = (1,)
print(tuple5)  # (1,)
print(type(tuple5))  # <class 'tuple'>

tuple6 = 1, 2, 3, 4, 5
print(tuple6)  # (1, 2, 3, 4, 5)
print(type(tuple6))  # <class 'tuple'>

**元组的特性：**元组的内部元素不可修改，不能增、删、改，但是元组可以切片。
元组的常用操作：
- 概述：元组只有查询功能
- 常用方法：
  - 通过索引值，查询内部元素
  - index()：查询指定元素在元组中从左到右第一次出现的索引值
  - count()：查询指定元素在元组中出现的次数
  - len()：查询元组中总共有几个元素
  - 元组的遍历时，和列表的遍历完全相同
- 代码示例：
```
tuple1 = ('秦始皇', '汉高祖', '汉光武帝')
print(tuple1[0])  # 秦始皇
print(tuple1.index('秦始皇'))  # 0
# print(tuple1.index('赵高'))  # ValueError: tuple.index(x): x not in tuple
print(tuple1.count('汉高祖'))  # 1
print(len(tuple1))  # 3
for item in tuple1:
    print(item)
```

5. 集合

集合的定义：

概述：在{}内添加元素就能完成集合的定义
格式：变量 = {元素1, 元素2, 元素3...}
创建空集合：变量 = set()，变量 = {}是创建一个空字典
定义单元素集合：变量 = {元素}

代码示例：

# 集合的定义
set1 = {1, 2, 3, 4, 5, 6, 7, 8, 9}
print(set1)  # {1, 2, 3, 4, 5, 6, 7, 8, 9}
print(type(set1))  # <class 'set'>
# 创建一个空集合
set2 = {}  # 这是空字典的创建
print(set2)  # {}
print(type(set2))  # <class 'dict'>
set3 = set()
print(set3)  # set()
print(type(set3))  # <class 'set'>
# 创建单元素集合
set4 = {3}
print(set4)
print(type(set4))  # <class 'set'>

集合的特性：
- 概述：集合的特性就是无序和不重复，常用于去除重复元素和进行集合运算。
- 无序性：容器内的数据元素顺序不可以被控制，所以不能使用索引。这意味着我们不能像列表和元组那样通过索引来访问集合中的元素。
- 不重复：写入到集合中的元素会自动去重，去重的规则就是判断哈希值是否相同。
- 在集合中，后添加进去的数据如果在容器中已经存在，则忽略，如果不存在，则添加。
- 集合可以使用for循环遍历
```
# 无序性
set1 = {1, 2, 3, 4}
set2 = {4, 2, 1, 3}
print(set1)  # {1, 2, 3, 4}
print(set2)  # {1, 2, 3, 4}
# 不重复
set3 = {1, 2, 3, 3, 2, 1}
print(set3)  # {1, 2, 3}
print(type(set3))  # <class 'set'>
# 数值型之间 False <=> 0，True <=> 1 <=> 1.0
set4 = {False, 2, 3, 1.0, 0, True}
print(set4)  # {False, 1.0, 2, 3}
print(type(set4))  # <class 'set'>
set5 = {'python', 'c', 'java'}
for item in set5:
    print(item)
```
**集合的使用场景：**通过将字符串或列表转换为集合，可以快速得到其中互异元素的个数。

6. 字典

字典的定义：
- 概述：通过键值对的方式来存储数据的容器，其中，键不可以重复。
- 格式：变量 = {键1: 值1, 键2: 值2, ...}
- 键值对：键就是这个值的唯一标识，通过键就可以获取值，在字典中值可以重复，键不能重复。
- 定义空字典：变量 = {}
- 注意：
  - 定义字典时，键值对必须成对出现
  - 字典无法使用索引
- 代码示例：
```
dict1 = {'name': '萧炎', 'age': 18, 'gender': '男'}
print(dict1)  # {'name': '萧炎', 'age': 18, 'gender': '男'}
print(type(dict1))  # <class 'dict'>

# 定义空字典
dict2 = {}
print(dict2)  # {}
print(type(dict2))  # <class 'dict'>
```

字典的增操作：

使用键=值的方式增加键值对，格式：变量[键] = 值
使用update()方法增加键值对，update()方法可以接受一个字典或关键字参数作为输入，将其键值对添加到原字典中。

代码示例：

dict1 = {'name': '萧炎', 'age': 18, 'gender': '男'}
dict1['weight'] = 70
print(dict1)  # {'name': '萧炎', 'age': 18, 'gender': '男', 'weight': 70}
dict1.update({'height': '180'})
print(dict1)  # {'name': '萧炎', 'age': 18, 'gender': '男', 'weight': 70, 'height': '180'}
dict1.update(address='Beijing', phone_number='555-4321')
print(dict1)  # {'name': '萧炎', 'age': 18, 'gender': '男', 'weight': 70, 'height': '180', 'address': 'Beijing', 'phone_number': '555-4321'}

字典的删操作：

字典的删除操作，只能按照键值对进行删除，不能只删除键或值
方法：
- pop()：可以根据指定的键删除对应的值，返回值是被删除的值，如果键不存在会报错
- popitem()：每次删除最后一对键值对。在 Python 3.7 及以后的版本中，字典是有序的，popitem()会删除最后插入的键值对。

代码示例：

dict1 = {'name': '萧炎', 'age': 18, 'gender': '男', 'weight': 70, 'height': '180'}
value = dict1.pop('weight')  # 70
print(dict1)  # {'name': '萧炎', 'age': 18, 'gender': '男', 'height': '180'}
print(value)  # 70
# dict1.pop('address')  # KeyError: 'address'
dict1.popitem()
print(dict1)  # {'name': '萧炎', 'age': 18, 'gender': '男'}
dict1.popitem()
print(dict1)  # {'name': '萧炎', 'age': 18}

字典的改操作：
- 字典的改操作和增操作完全相同，新键值对的键在原字典中存在，就是改操作
- 使用update()可以一次性既增加键值对，又修改键值对

字典的查操作：

使用键查询值：变量[键]，如果键不存在则报错
使用get()方法查询数据，如果没有键会自动返回默认值None，也可以指定返回的默认值
keys()：查询字典中所有的键
values()：查询字典中所有的值
items()：查询字典中所有的键值对，以元组的方式返回每一个键值对

代码示例：

dict1 = {'name': '萧炎', 'age': 18, 'gender': '男'}
print(dict1['name'])
print(dict1['age'])
print(dict1['gender'])
# print(dict1['weight'])  # KeyError: 'weight'
print(dict1.get('name'))
print(dict1.get('age'))
print(dict1.get('gender'))
print(dict1.get('weight'))  # None
print(dict1.get('height', '180'))  # 180
print(dict1.keys())  # dict_keys(['name', 'age', 'gender'])
print(dict1.values())  # dict_values(['萧炎', 18, '男'])
print(dict1.items())  # dict_items([('name', '萧炎'), ('age', 18), ('gender', '男')])

字典的遍历：

直接遍历字典，就是依次获取字典中的每一个key值
使用keys()方法进行遍历，此时获取的也是每一个key值
使用values()方法进行遍历，此时获取的是字典中每一个value值
使用items()方法进行遍历，此时获取的是字典中每一个键值对组成的元组

代码示例：

dict1 = {'name': '萧炎', 'age': 18, 'gender': '男', 'weight': 70, 'height': '180'}
for key in dict1:
    print(key)
for key in dict1.keys():
    print(key)
for value in dict1.values():
    print(value)
for item in dict1.items():
    print(item)
for key, value in dict1.items():
    print(key, value)

7. 容器的公共运算符

加法运算符：
- 容器类型数据的相加，就是容器数据的合并（拼接）。
- 容器类型的加法运算不会修改原有的数据，而是产生了一个新容器。
- 集合和字典不支持加法运算，因为集合的无序性和不重复性以及字典键的唯一性，使得加法运算在这些容器中没有明确的定义。
- 容器间的加法运算只能在相同数据类型的容器间进行。
- 代码示例：
```
# str
print('123' + 'abc')  # 123abc
# list
print([1, 2, 3] + ['a', 'b', 'c'])  # [1, 2, 3, 'a', 'b', 'c']
# tuple
print((1, 2, 3) + ('a', 'b', 'c'))  # (1, 2, 3, 'a', 'b', 'c')
# set
# print({1, 2, 3} + {'a', 'b', 'c'})  # TypeError: unsupported operand type(s) for +: 'set' and 'set'
# dict
# print({'name': 'Tom'} + {'age': 18})  # TypeError: unsupported operand type(s) for +: 'dict' and 'dict'
```
乘法运算符：
- 容器与数值相乘就是将容器复制n份并相加。
- 容器类型的乘法运算不会修改原有的数据，而是产生了一个新容器。
- 不能进行加法运算的数据类型一样不能进行乘法运算。
- 容器类型仅能与整型数据进行乘法运算。

in not in

判断元素是否在容器内，判断字典类型数据时，判断的是键是否存在。
判断字符串时，只能判断字符元素是否在字符串中，不能判断数值型数据是否在字符串中。

代码示例：

# in not in
dict1 = {'name': 'Jake', 'age': 18}
print('name' in dict1)  # True
print('Jake' in dict1)  # False

str1 = 'python111'
print('p' in str1)  # True
print('pyt' in str1)  # True
# print(1 in str1)  # TypeError: 'in <string>' requires string as left operand, not int
print(1 in [1, 2, 3])  # True
print(1 in (1, 2, 3))  # True
print(1 in {1, 2, 3})  # True

8. 容器的公共函数

len：获取容器中元素的个数
del：不能删除集合中的元素，无法删除字符串和元组内的元素。因为集合、字符串和元组是不可变类型，del操作只能删除整个容器变量，而不能删除其中的元素
max：获取容器中的最大值。对于字典，max默认比较的是键
min：获取容器中的最小值。对于字典，min默认比较的是键

sum：获取容器内所有数据的和，使用sum时，要保证所有数据的数据类型一致（容器和非容器）

list1 = [1, 2, 3]
print(max(list1))  # 3
print(min(list1))  # 1
dict1 = {'a': 2, 'b': 3, 'c': 1}
print(max(dict1))  # c
print(min(dict1))  # a

print(sum([1, 2, 3]))  # 6
print(sum([1, 2, 3.1, True]))  # 6

9. 可变数据类型和不可变数据类型

**可变数据类型：**内存空间中的数据可以被修改的数据类型。
- 列表：可以通过增删改操作修改列表中的元素
- 集合：可以添加或删除元素
- 字典：可以增加、删除或修改键值对
**不可变数据类型：**内存空间中的数据不可以被修改的数据类型。
- int：整数类型，一旦创建，其值不能改变
- float：浮点数类型，同样不可修改
- bool：布尔类型，只有True和False两个值，不可修改
- str：字符串类型，虽然可以进行切片等操作，但实际上是产生了新的字符串，原字符串并没有改变
- tuple：元组类型，元素不可修改。