3. Python 数据容器（列表、元组、字符串、集合、字典）

1. 数据容器入门

数据容器：一种可以容纳多份数据的数据类型，容纳的每份数据称为一个元素。
每个元素，可以是任意类型数据，如：字符串、数字、布尔等。

数据容器根据特点的不同，如：

• 是否支持重复元素
• 是否可以修改
• 是否有序，等

分为 5 类，分别是：列表（list）、元组（tuple）、字符串（str）、集合（set）、字典（dict）。我们将一 一学习它们。

2. list（列表）

2.1 列表的定义

列表内的每一个数据，称为元素。
列表以[]作为标识，其中的元素之间用，隔开。

基本语法：

#字面量
[元素1, 元素2, 元素3, 元素4, ...]
#定义变量
变量名称 = [元素1, 元素2, 元素3, 元素4, ...]
#定义空列表
变量名称 = []
变量名称 = 1ist()

注意：列表可以一次存储多个数据，且可以为不同、任意的数据类型，支持嵌套。

# 一次存储多个数据
name_list = ["tom", "jerry", "jack"]
print(name_list)
print(type(name_list))
# 列表中可以存储不同的数据类型
my_list1 = ["it", True, 123]
print(my_list1)
print(type(my_list1))
# 列表支持嵌套
my_list2 = [[1, 2, 3], [5, 6, 7]]
print(my_list2)
print(type(my_list2))

输出结果：

['tom', 'jerry', 'jack']
<class 'list'>
['it', True, 123]
<class 'list'>
[[1, 2, 3], [5, 6, 7]]
<class 'list'>

2.2 列表的下标索引

2.2.1 列表的正向索引

name_list = ["tom", "jerry", "jack"]
print(name_list[0]) 
print(name_list[1])
print(name_list[2])

输出结果：

tom
jerry
jack

2.2.2 列表的反向索引

name_list = ["tom", "jerry", "jack"]
print(name_list[-1])
print(name_list[-2])
print(name_list[-3])

输出结果：

jack
jerry
tom

2.2.3 嵌套列表同样支持索引

上图中，若要访问红框中的元素：列表名[1][0]，形似 C 语言的二维数组。

my_list = [[1, 2, 3], [5, 6, 7]]
print(my_list[1][0]) #输出5

注意：不要超出下标索引的取值范围，否则无法取出元素，并且会报错。（类似数组不能越界）

2.3 列表的常用操作 / 方法

编号	使用方式	作用
1	列表.index(元素)	返回元素的第一个匹配项在列表中的下标，找不到报错 ValueError
2	列表.insert(下标, 元素)	在指定下标处，插入指定元素
3	列表.append(元素)	向列表末尾追加一个元素
4	列表.extend(容器)	将数据容器的内容依次取出，追加到列表尾部
5	del 列表[下标]	删除列表指定下标元素
6	列表.pop(下标)	删除列表指定下标元素，并返回删除的元素
7	列表.remove(元素)	从前向后，删除此元素的第一个匹配项
8	列表.clear()	清空列表
9	列表.count(元素)	返回此元素在列表中出现的次数
10	len(列表)	返回容器内有多少个元素

(1) index: 返回元素的第一个匹配项在列表中的下标，找不到报错 ValueError

name_list = ["tom", "jerry", "jack"]
print(name_list.index("jerry")) #1
#若有2个jerry，返回第一个jerry的下标

name_list = ["tom", "jerry", "jack"]
# ValueError: 'hello' is not in list
print(name_list.index("hello")) 

修改特定位置（索引）的元素值：
使用如上语法，可以直接对指定下标（正向、反向下标均可）的值进行修改。

name_list = ["tom", "jerry", "jack"]
name_list[0] = "smith"
print(name_list)

输出结果：

['smith', 'jerry', 'jack']

(2) insert: 在指定下标处，插入指定元素

name_list = ["tom", "jerry", "jack"]
name_list.insert(1, 123)
print(name_list)

输出结果：

['tom', 123, 'jerry', 'jack']

(3) append: 向列表末尾追加一个元素

num_list = [1, 2, 3]
num_list.append(4)
print(num_list)
# 重新赋值
num_list = [1, 2, 3]
num_list.append([4, 5, 6])
print(num_list)

输出结果：

[1, 2, 3, 4]
[1, 2, 3, [4, 5, 6]]

(4) extend: 将数据容器的内容依次取出，追加到列表尾部

num_list = [1, 2, 3]
num_list.extend([4, 5, 6])
print(num_list)

输出结果：

[1, 2, 3, 4, 5, 6]

(5) del: 删除指定下标元素方式1

# 方法1
num_list = [1, 2, 3]
del num_list[0]
print(num_list)

输出结果：

[2, 3]

(6) pop: 删除指定下标元素方式2

# 方法2
num_list = [1, 2, 3]
element = num_list.pop(0)#删除并得到删除元素
print(f"删除的元素为{element}")
print(num_list)

输出结果：

删除的元素为1
[2, 3]

(7) remove: 从前向后，删除此元素的第一个匹配项

my_list = ["tom", "jerry", "smith", "jerry", "green"]
my_list.remove("jerry") #删除第一个jerry
print(my_list)

输出结果：

['tom', 'smith', 'jerry', 'green']

(8) clear: 清空列表内容

my_list = ["tom", "jerry", "smith", "jerry", "green"]
my_list.clear()
print(my_list)

输出结果：

[]

(8) len: 返回某元素在列表内的数量

my_list = ["tom", "jerry", "jerry", "jerry", "green"]
print(my_list.count("jerry"))

输出结果：

3

(9) count: 返回列表内，共有多少个元素

my_list = ["tom", "jerry", "smith", "jerry", "green"]
print(len(my_list))

输出结果：

5

经过对列表的学习，可以总结出列表有如下特点：

• 可以容纳多个元素（上限为2**63 - 1 = 9223372036854775807 个）
• 可以容纳不同类型的元素（混装）
• 数据是有序存储的（有下标序号）
• 允许重复数据存在
• 可以修改（增加或删除元素等）

2.4 列表的循环遍历

2.4.1 while 循环遍历列表

基本语法：

index = 0
while index < len(列表):
	元素 = 列表[index]
	对元素进行处理
	index += 1

【例】

my_list = [1, 2, 3, 4]

index = 0
while index < len(my_list):
    num = my_list[index]
    print(num)
    index += 1

输出结果：

1
2
3
4

2.4.2 for 循环遍历列表

相对 while 循环来说，for 循环更适合遍历列表等数据容器。

基本语法：

for 临时变量 in 数据容器:
	对临时变量进行处理

上面代码表示：从容器内，依次取出元素并赋值到临时变量上。
在每一次的循环中，可以对临时变量（元素）进行处理。

【例】

my_list = [1, 2, 3, 4]
for element in my_list:
    print(element)

输出结果：

1
2
3
4

while 循环和 for 循环对比：

• 在循环控制上：
  while 循环可以自定循环条件，并自行控制。
  for 循环不可以自定循环条件，只能逐个地从容器内取出数据。
• 在无限循环上：
  while 循环可以通过条件控制做到无限循环。
  for 循环理论上不可以，因为被遍历的容器容量不是无限的。
• 在使用场景上：
  whle 循环适用于任何想要循环的场景。
  for 循环适用于，遍历数据容器或简单的固定次数循环。

由此看出，for 循环更简单，while 循环更灵活。
for 循环今后会更常用些。

3. tuple（元组）

3.1 元组的定义

列表是可以修改的。如果想要传递的信息，不能被篡改，列表就不合适了，这时就要用到元组。
元组同列表一样，都可以封装多个、不同类型的元素。但不同点在于：元组一旦定义完成，就不可修改。

• 元组定义：定义元组使用小括号，且使用逗号隔开各个数据，数据可以是不同的数据类型。

  #定义元组字面量
  (元素, 元素, ..., 元素)
  
  # 定义元组变量
  变量名称 = (元素, 元素, ..., 元素)
  
  #定义空元组
  #方式1
  变量名称 = ()
  #方式2
  变量名称 = tuple()
  

  【例】

  # 定义3个元素的元组
  t1 = (1, 'Hello', True)
  

  注意：定义只含一个元素的元组时，元素后必须带有逗号，否则不是元组类型。

  t1 = ("hello")
  print(f"t1的类型是：{type(t1)}")
  t2 = ("hello",)
  print(f"t2的类型是：{type(t2)}")
  

  输出结果：

  t1的类型是：<class 'str'>
  t2的类型是：<class 'tuple'>
  

• 元组支持嵌套

  t = ((1, 2, 3), (4, 5, 6))
  print(t)
  

  输出结果：

  ((1, 2, 3), (4, 5, 6))
  

• 根据下标取出元组内容（从前向后：从 0 开始；从后向前：从 -1 开始）

  t = ((1, 2, 3), (4, 5, 6))
  print(t[1][1])
  

  输出结果：

  5
  

3.2 元组的操作 / 方法

因为元组不可修改的特性，元组的操作 / 方法还是比较少的。

编号	方法	作用
1	元组.index(元素)	返回元素的第一个匹配项在元组中的下标，否则报错
2	元组.count(元素)	返回某个数据在元组中出现的次数
3	len(元组)	返回元组内的元素个数

t = ("tom", "jerry", "jack", "smith", "jerry")
print(f'jerry的下标是：{t.index("jerry")}')
print(f'jerry的数量是：{t.count("jerry")}')
print(f"元组t的长度是：{len(t)}")

输出结果：

jerry的下标是：1
jerry的数量是：2
元组t的长度是：5

经过对元组的学习，可以总结出元组有如下特点：

• 可以容纳多个数据
• 可以容纳不同类型的数据（混装）
• 数据是有序存储的（下标索引）
• 允许重复数据存在
• 不可以修改（增加或删除元素等）

元组的多数特性与列表（list）一致，不同点在于不可修改。

【例】定义一个元组，内容是：(“jack”, 11, [“football”, “music”])，记录的是一个学生的信息（姓名、年龄、爱好）。通过元组的功能（方法），对其进行：
（1）查询其年龄所在的下标位置；
（2）查询学生的姓名；
（3）删除学生爱好中的 football；
（4）增加爱好 coding 到爱好 list 内。

my_list = ("jack", 11, ["football", "music"])
print(f"元组初始为: {my_list}")
print(f"年龄所在的下标位置: {my_list.index(11)}")
print(f"学生姓名: {my_list[0]}")
my_list[2].pop(0) #或：del my_list[2][0]
print(f"删除学生爱好football后，元组为: {my_list}")
my_list[2].append("coding")
print(f"增加学生爱好coding后，元组为: {my_list}")

输出结果：

元组初始为: ('jack', 11, ['football', 'music'])
年龄所在的下标位置: 1
学生姓名: jack
删除学生爱好football后，元组为: ('jack', 11, ['music'])
增加学生爱好coding后，元组为: ('jack', 11, ['music', 'coding'])

3.3 元组的遍历

while 循环：

t = ("tom", "jerry", "jack", "smith")
index = 0
while index < len(t):
    print(t[index])
    index += 1

for 循环：

t = ("tom", "jerry", "jack", "smith")
for element in t:
    print(element)

上面两份代码都输出：

tom
jerry
jack
smith

3.4 元组注意事项

（1）不可以修改元组的内容，否则会直接报错。

#尝试修改元组内容
t1 = (1, 2, 3)
t1[0] = 5

（2）可以修改元组内的 list 的内容（修改元素、增加、删除、反转等）。

t1 = (1, 2, ['itheima', 'itcast'])
print(f"t1修改前：{t1}")
t1[2][1] = 'best'
print(f"t1修改后：{t1}")

输出结果：

t1修改前：(1, 2, ['itheima', 'itcast'])
t1修改后：(1, 2, ['itheima', 'best'])

4. str（字符串）

4.1 字符串的定义

  尽管字符串看起来并不像列表、元组那样，一看就是存放了许多数据的容器。但不可否认的是，字符串同样也是数据容器的一员。
  字符串是字符的容器，一个字符串可以存放任意数量的字符。如，字符串：“itheima”。

字符串的下标（索引）：从前向后，下标从0开始；从后向前，下标从-1开始。

name = "itheima"
print(name[0]) #结果i
print（name[-1]）#结果a

同元组一样，字符串是无法修改的数据容器。所以：

• 修改指定下标的字符（如：字符串[0] = “a”）
• 移除特定下标的字符（如：del 字符串[0]、字符串.remove(）、字符串.pop(）等）
• 追加字符 等（如：字符串.append(））
  均无法完成。如果必须要做，只能得到一个新的字符串，旧的字符串无法修改。

4.2 字符串的常用操作

编号	操作	说明
1	字符串.index(字符串)	查找给定字符的第一个匹配项的下标。
2	字符串.replace(字符串1,字符串2)	将字符串内的全部字符串1，替换为字符串2。 不改变原字符串。
3	字符串.split(字符串)	按照给定字符串，对字符串进行分割。 不改变原字符串。
4	字符串.strip() 字符串.strip(字符串)	移除首尾的空格、tab、或换行符。 移除首尾的指定字符串。 不改变原字符串。
5	字符串.count(字符串)	统计字符串内某字符串的出现次数。
6	len(字符串)	统计字符串的字符个数。

(1) index：查找特定字符串的下标

my_str = "itcast and itheima"
print(my_str.index("and")) # 输出7

(2) replace：字符串的替换

my_str = "itcast and itheima"
new_str = my_str.replace("it", "**")
print(f"原字符串：{my_str}")
print(f'替换后的字符串：{new_str}')

输出结果：

原字符串：itcast and itheima
替换后的字符串：**cast and **heima

(3) split：字符串的分割

my_str = "hello python itheima itcast"
my_list = my_str.split(" ")
print(my_str)
print(my_list)
print(type(my_list))

输出结果：

hello python itheima itcast
['hello', 'python', 'itheima', 'itcast']
<class 'list'>

(4) strip：返回规整后的字符串

• 去前后空格、tab、换行

  my_str =" 	itheima and itcast \n"
  print(my_str.strip())#结果："itheima and itcast"
  

• 去前后指定字符串

  my_str ="12itheima and itcast21"
  print(my_str.strip("12"))#结果："itheima and itcast"
  

  虽然传入的参数是 ”12“，但是末尾的 ”21“ 也被去掉了。这是因为开头和结尾部分的字符只要是 ”1“、”2“ 之中的，就会被去掉。下面再举一例：

  my_str ="123itheima and itcast121"
  print(my_str.strip("123")) #输出：itheima and itcast
  

(5) count：返回一个字符串中某字符串的出现次数

my_str = "itheima and itcast"
print(my_str.count("it")) # 输出2

(6) len：返回字符串的长度

my_str = "he llo"
print(len(my_str)) # 输出6

作为数据容器，字符串有如下特点：

• 只可以存储字符串，不像列表、元组可以存任意类型。
• 长度任意（取决于内存大小）。
• 支持下标索引。
• 允许重复字符串存在。
• 不可以修改（增加或删除元素等）。

4.3 字符串的遍历

while 循环：

my_str = "hello"
index = 0
while index < len(my_str):
    print(my_str[index])
    index += 1

for 循环：

my_str = "hello"
for ch in my_str:
    print(ch)

【例】给定一个字符串：“itheima itcast boxuegu”，要求：
（1）统计字符串内有多少个”it"字符；
（2）将字符串内的空格，全部替换为字符：”|”；
（3）并按照|进行字符串分割，得到列表。

my_str = "itheima itcast boxuegu"
print(my_str.count("it"))
new_str = my_str.replace(" ", "|")
print(new_str)
print(new_str.split("|"))

输出结果：

2
itheima|itcast|boxuegu
['itheima', 'itcast', 'boxuegu']

5. 数据容器的切片

序列：内容连续、有序，可使用下标索引的一类数据容器。列表、元组、字符串，均可以可以视为序列。

序列支持切片，即：列表、元组、字符串，均支持切片操作。

切片：从一个序列中，取出一个子序列。
语法：序列名[起始下标:结束下标:步长]，表示从序列的指定位置开始，依次取出元素，到指定位置结束，得到一个新序列：

• 起始下标：表示从何处开始，可以留空，留空视作从头开始。
• 结束下标（不含）：表示何处结束，可以留空，留空视作截取到结尾。
• 步长：表示依次取元素的间隔。
  步长 1 表示，一个个取元素
  步长 2 表示，每次跳过 1 个元素取
  步长 N 表示，每次跳过 N - 1 个元素取
  步长为负数表示，反向取（注意：起始下标和结束下标也要反向标记）

注意，此操作不会影响序列本身，而是会得到一个新的序列（列表、元组、字符串）

#对list切片，从1开始，到4结束，步长1
my_list=[0, 1, 2, 3, 4, 5, 6]
result1 = my_list[1:4]#步长默认是1，所以可以省略不写
print(result1)#[1, 2, 3]
#对tuple切片，从头开始，到最后结束，步长1
my_tuple = (0, 1, 2, 3, 4, 5, 6)
result2 = my_tuple[:]#起始和结束不写表示从头到尾
print(result2)#(0, 1, 2, 3, 4, 5, 6)
#对str进科切片，从头开始，到最后结束，步长2
my_str = "01234567"
result3 = my_str[::2]#步长为2
print(result3)#0246
#对str进行切片，从头开始，到最后结束，步长-1
my_str = "01234567"
result4 = my_str[::-1]#等同于序列反转
print(result4)#76543210
#对列农进行切片，从3开始，到1结束，步长-1
my_list = [0, 1, 2, 3, 4, 5, 6]
result5 = my_list[3:1:-1]#注意开始和结束下标，按正向
print(result5)#[3, 2]
#对元组进行切片，从头开始，到尾结束。步长-2
my_tuple = (0, 1, 2, 3, 4, 5, 6)
result6 = my_tuple[::-2]
print(result6)#(6, 4, 2, 0)

【例】有字符串："万过薪月，员序程马黑来，nohtyP学”。请使用学过的任何方式，得到 ”黑马程序员”。

my_str = "万过薪月，员序程马黑来，nohtyP学"
# 方法1
result1 = my_str[5:10][::-1]
print(result1)
# 方法2
result2 = my_str[::-1][9:14]
print(result2)
# 方法3
result3 = my_str.split("，")[1].replace("来", "")[::-1]
print(result3)

6. set（集合）

6.1 集合的定义

如果需要对内容做去重处理，列表、元组、字符串就不方便了。
而集合，最主要的特点就是：不支持元素的重复（自带去重功能）、内容无序。

#定义集合字面量
{元素, 元素, ..., 元素}
#定义集合变量
变量名称 = {元素, 元素, ..., 元素}
#定义空集合
变量名称 = set()
# 定义空集合不能使用 “变量名称 = {}”，因为这是空字典的一种定义方式（后面7.1会讲到）

在此总结一下前面所学容器使用的符号：
(1) 列表使用：[]
(2) 元组使用：()
(3) 字符串使用：“”
(4) 集合使用：{}

my_set = {"tom", "jerry", "jack", "jerry", "tom"}
print(my_set, type(my_set))
empty_set = set()
print(empty_set, type(empty_set))

输出结果：

{'jack', 'jerry', 'tom'} <class 'set'>
set() <class 'set'>

my_set 的输出结果表明：集合元素不允许重复，且元素无序。

6.2 集合的操作 / 方法

因为集合是无序的，所以集合不支持按下标访问。但是集合和列表一样，是允许修改的。

操作	说明	编号
1	集合.add(元素)	集合内添加一个元素。
2	集合.remove(元素)	移除集合内指定的元素。
3	集合.pop()	从集合中随机取出一个元素。
4	集合.clear()	将集合清空。
5	集合1.difference(集合2)	得到一个新集合，内含2个集合的差集。原有的2个集合内容不变。
6	集合1.difference_update(集合2)	更新集合1为 两个集合（集合1、集合2）的差集。
7	集合1.union(集合2)	得到1个新集合，内含2个集合的全部元素。原有的2个集合内容不变。
8	len(集合)	得到一个整数，记录了集合的元素数量。

(1) add：添加新元素
语法：集合.add(元素)。将指定元素，添加到集合内。
结果：集合本身被修改，添加了新元素。

my_set = {"Hello","world"}
my_set.add("itheima")
my_set.add("Hello") #已经有了，添加不进去
print(my_set) #输出{'world', 'Hello', 'itheima'}
# 可能顺序不同，但元素都是那几个

(2) remove：移除元素
语法：集合.remove(元素)，将指定元素，从集合内移除。
结果：集合本身被修改，移除了元素。

my_set = {"Hello", "world", "itheima"}
my_set.remove("Hello")
print(my_set) #结果{'world','itheima'}

(3) pop：从集合中随机取出元素
语法：集合.pop()，从集合中随机取出一个元素。.
结果：会得到取出的元素。同时集合本身被修改，元素被移除。

my_set = {"Hello", "world", "itheima"}
element = my_set.pop()
# 结果'Hello', 也可能是其他元素，因为随机取
print(element)
#结果{'world'，'itheima'}
print(my_set)

(4) clear：清空集合

my_set = {"Hello", "world", "itheima"}
my_set.clear()
print(my_set) #输出set()

(5) difference：取出 2 个集合的差集
语法：集合1.difference(集合2），取出集合1和集合2的差集（集合1有而集合2没有的）。
结果：得到一个新集合，集合1和集合2不变。

set1 = {1, 2, 3}
set2 = {1, 5, 6}
set3 = set1.difference(set2)
print(set3)#结果：{2，3}，集合1有而集合2没有的
print(set1)#结果：{1，2，3}不变
print(set2)#结果：{1，5，6]不变

(6) difference_update：更新集合为 2 个集合的差集
语法：集合1.difference_update(集合2)
功能：将集合1更新为集合1与集合2的差集（集合1有而集合2没有的）。
结果：集合1被修改，集合2不变。

set1 = {1, 2, 3}
set2 = {1, 5, 6}
set1.difference_update(set2)
print(set1)#结果：{2，3]
print(set2)#结果：{1，5，6]

(7) union：2个集合合并
语法：集合1.union(集合2）
功能：将集合1和集合2组合成新集合
结果：得到新集合，集合1和集合2不变

set1 = {1, 2, 3}
set2 = {1, 5, 6}
set3 = set1.union(set2)
print(set3)#结果：{1，2，3，5，6}，新集合
print(set1)#结果：{1，2，3}，set1不变
print(set2)#结果：{1，5，6}，set2不变

(8) len：返回集合元素数量

set1 = {1, 2, 3, 4}
print(len(set1))#输出4
set2 = {1, 2, 3, 4, 1, 2, 3, 4}
print(len(set2))#输出4

经过上述对集合的学习，可以总结出集合有如下特点：

• 可以容纳多个数据
• 可以容纳不同类型的数据（混装）
• 数据是无序存储的（不支持下标索引）
• 不允许重复数据存在
• 可以修改（增加或删除元素等）
• 支持for循环，不支持 while 循环

6.3 集合的遍历

集合的遍历：集合不支持下标索引，所以不能用 while 循环，但可以用 for 循环。

set1 = {1, 2, 3, 4}
for element in set1:
    print(element)

【例】有如下列表对象：
my_list=[‘黑马程序员’，‘传智播客’，‘黑马程序员’，‘传智播客’，‘itheima’,‘itcast’,‘itheima’,‘itcast’,
‘best’]
请：
(1) 定义一个空集合
(2) 通过for循环遍历列表
(3) 在for循环中将列表的元素添加至集合
(4) 最终得到元素去重后的集合对象，并打印输出

7. dict（字典）

7.1 字典的定义

使用字典，可以实现 “通过 key 取出 value 的操作”。
字典的定义，同样使用 {}，不过存储的元素是一个个的键值对，如下语法：

#定义字典字面量
{key: value, key: value, ..., key: value}

#定义字典变量
my_dict = {key: value, key: value, ..., key: value}

#定义空字典
#空字典定义方式1
my_dict = {}
#空字典定义方式2
my_dict = dict()

字典的 key 不允许重复： 重复添加等同于覆盖原有数据

my_dict = {"tom":99, "tom":88, "jack":77}
print(my_dict)

输出结果：

{'tom': 88, 'jack': 77}

字典数据的获取
字典同集合一样，不可以使用下标索引。但是字典可以通过 Key 值来取得对应的 Value。

my_dict = {"tom":99, "jerry":88, "jack":77}
print(my_dict["tom"])
print(my_dict["jerry"])
print(my_dict["jack"])

输出结果：

99
88
77

字典可以嵌套
字典的 Key 和 Value 可以是任意数据类型（Key 不可为字典），所以，字典是可以嵌套的。

有需求如下：记录学生各科的考试信息。

姓名	语文	数学	英语
tom	77	88	99
jerry	99	88	77
jack	88	99	77

my_dict = {
    "tom":{
        "语文":77,
        "数学":88,
        "英语":99
    },
    "jerry":{
        "语文":99,
        "数学":88,
        "英语":77
    },
    "jack":{
        "语文":88,
        "数学":99,
        "英语":77
    }
}
print(my_dict)
print(f'tom的语文成绩是：{my_dict["tom"]["语文"]}')

7.2 字典的操作 / 方法

编号	操作	说明
1	字典[Key] = Value	添加新元素或更新 Value 值
2	字典.pop(Key)	取出 Key 对应的 Value 并在字典内删除此 Key 的键值对
3	字典.clear()	清空字典
4	字典.keys()	获取字典的全部 Key，可用于 for 循环遍历字典
5	len(字典)	计算字典内的元素数量

（1）更新 / 新增元素
语法：字典[Key] = Value
结果：若 Key 存在，就更新对应的 Value 值，若 Key 不存在，就新增元素。

my_dict = {"tom":99, "jerry":88, "jack":77}
my_dict["tom"] = 100
print(my_dict)
my_dict["smith"] = 90
print(my_dict)

输出结果：

{'tom': 100, 'jerry': 88, 'jack': 77}
{'tom': 100, 'jerry': 88, 'jack': 77, 'smith': 90}

（2）pop：删除元素
语法：字典.pop(Key)
结果：删除 Key 对应的元素，并返回其 Value 值。

my_dict = {"tom":99, "jerry":88, "jack":77}
value = my_dict.pop("jerry")
print(value)
print(my_dict)

输出结果：

88
{'tom': 99, 'jack': 77}

（3）clear：清空字典
语法：字典.clear()
结果：字典被修改，元素被清空。

my_dict = {"tom":99, "jerry":88, "jack":77}
my_dict.clear()
print(my_dict)

输出结果：

{}

（4）keys：获取全部的 Key
语法：字典.keys()
结果：得到字典中的全部 Key。

my_dict = {"tom":99, "jerry":88, "jack":77}
keys = my_dict.keys()
print(keys)
print(type(keys))

输出结果：

dict_keys(['tom', 'jerry', 'jack'])
<class 'dict_keys'>

（5）len：统计字典内的元素数量

my_dict = {"tom":99, "jerry":88, "jack":77}
print(len(my_dict))#输出3

经过上述对字典的学习，可以总结出字典有如下特点：

• 可以容纳多个数据
• 可以容纳不同类型的数据
• 每一份数据是 Key-Value 键值对
• 可以通过 Key 获取到 Value，Key 不可重复（重复会覆盖）
• 不支持下标索引
• 可以修改（增加或删除更新元素等）
• 支持 for 循环，不支持 while 循环

7.3 字典的遍历

方法1：通过7.2提到的方式获取到的全部 Key 来遍历。

my_dict = {"tom":99, "jerry":88, "jack":77}
keys = my_dict.keys()
for key in keys:
    print(key, my_dict[key])

输出结果：

tom 99
jerry 88
jack 77

方法2：直接对字典 for 循环。

my_dict = {"tom":99, "jerry":88, "jack":77}
for key in my_dict:
    print(key, my_dict[key])

输出结果：

tom 99
jerry 88
jack 77

因为字典不支持下标索引，所以不支持 while 循环。

8. 数据容器的分类（对前面的总结）

	列表	元组	字符串	集合	字典
元素数量	支持多个	支持多个	支持多个	支持多个	支持多个
元素类型	任意	任意	仅字符	任意	Key:Value Key：除字典外的任意类型 Value：任意类型
下标索引	支持	支持	支持	不支持	不支持
重复元素	支持	支持	支持	不支持	不支持
可修改性	支持	不支持	不支持	支持	支持
数据有序	是	是	是	否	否
使用场景	一批数据，可修改、可重复的存储	一批数据，不可修改、可重复	一串字符串	一批数据，去重存储	一批数据，可用 Key 检索 Value

9. 数据容器的通用操作

数据容器各有各的特点，但也有一些通用操作。

功能	描述
通用 for 循环	遍历容器（字典是遍历key）
max()	容器内最大元素（字典是最大的 Key 串，按ascii）
min()	容器内最小元素（字典是最小的 Key 串，按ascii）
len()	容器元素个数
list()	转换为列表
tuple()	转换为元组
str()	转换为字符串
set()	转换为集合
sorted(序列,[reverse=True])	排序，reverse=True表示降序 得到一个排好序的列表 字典是按 ascii 排 Key 串

(1) for 循环遍历
五类数据容器都支持 for 循环遍历。
列表、元组、字符串支持 while 循环，集合、字典不支持（因为无法下标索引）。
尽管遍历的形式各有不同，但是，它们都支持遍历操作。

(2) 数据容器通用的功能方法
len(容器)：统计容器中的元素个数
max(容器)：统计容器中的最大元素
min(容器)：统计容器中的最小元素

my_list = [1, 2, 3, 4, 5]
my_tuple = (1, 2, 3, 4, 5)
my_str = "abcdefg"
my_set = {1, 2, 3, 4, 5}
my_dict = {"key4": 1, "key5": 2, "key3": 3, "key1": 4, "key2": 5}
print(len(my_list), max(my_list),min(my_list))
print(len(my_tuple),max(my_tuple),min(my_tuple))
print(len(my_str),max(my_str),min(my_str))
print(len(my_set),max(my_set),min(my_set))
print(len(my_dict),max(my_dict),min(my_dict))#Key串的最大最小值

输出结果：

5 5 1
5 5 1
7 g a
5 5 1
5 key5 key1

(3) 数据类型通用类型转换

list(容器)：将给定容器转换为列表

my_list = [1, 2, 3, 4, 5]
my_tuple = (1, 2, 3, 4, 5)
my_str = "abcdefg"
my_set = {1, 2, 3, 4, 5}
my_dict = {"key1": 1, "key2": 2, "key3": 3, "key4": 4, "key5": 5}
print(f"列表转列表：{list(my_list)}")
print(f"元组转列表：{list(my_tuple)}")
print(f"字符串转列表：{list(my_str)}")
print(f"集合转列表：{list(my_set)}")
print(f"字典转列表：{list(my_dict)}")#仅保留key

输出结果：

列表转列表：[1, 2, 3, 4, 5]
元组转列表：[1, 2, 3, 4, 5]
字符串转列表：['a', 'b', 'c', 'd', 'e', 'f', 'g']
集合转列表：[1, 2, 3, 4, 5]
字典转列表：['key1', 'key2', 'key3', 'key4', 'key5']

tuple(容器)：将给定容器转换为元组

my_list = [1, 2, 3, 4, 5]
my_tuple = (1, 2, 3, 4, 5)
my_str = "abcdefg"
my_set = {1, 2, 3, 4, 5}
my_dict = {"key1": 1, "key2": 2, "key3": 3, "key4": 4, "key5": 5}
print(f"列表转元组：{tuple(my_list)}")
print(f"元组转元组：{tuple(my_tuple)}")
print(f"字符串转元组：{tuple(my_str)}")
print(f"集合转元组：{tuple(my_set)}")
print(f"字典转元组：{tuple(my_dict)}")#仅保留key

输出结果：

列表转元组：(1, 2, 3, 4, 5)
元组转元组：(1, 2, 3, 4, 5)
字符串转元组：('a', 'b', 'c', 'd', 'e', 'f', 'g')
集合转元组：(1, 2, 3, 4, 5)
字典转元组：('key1', 'key2', 'key3', 'key4', 'key5')

str(容器)：将给定容器转换为字符串

my_list = [1, 2, 3, 4, 5]
my_tuple = (1, 2, 3, 4, 5)
my_str = "abcdefg"
my_set = {1, 2, 3, 4, 5}
my_dict = {"key1": 1, "key2": 2, "key3": 3, "key4": 4, "key5": 5}
print(f"列表转字符串：{str(my_list)}")
print(f"元组转字符串：{str(my_tuple)}")
print(f"字符串转字符串：{str(my_str)}")
print(f"集合转字符串：{str(my_set)}")
print(f"字典转字符串：{str(my_dict)}")

输出结果：实际都是带""的

列表转字符串：[1, 2, 3, 4, 5]
元组转字符串：(1, 2, 3, 4, 5)
字符串转字符串：abcdefg
集合转字符串：{1, 2, 3, 4, 5}
字典转字符串：{'key1': 1, 'key2': 2, 'key3': 3, 'key4': 4, 'key5': 5}

set(容器)：将给定容器转换为集合（会去重、无序）

my_list = [1, 2, 3, 4, 5]
my_tuple = (1, 2, 3, 4, 5)
my_str = "abcdefg"
my_set = {1, 2, 3, 4, 5}
my_dict = {"key1": 1, "key2": 2, "key3": 3, "key4": 4, "key5": 5}
print(f"列表转集合：{set(my_list)}")
print(f"元组转集合：{set(my_tuple)}")
print(f"字符串转集合：{set(my_str)}")
print(f"集合转集合：{set(my_set)}")
print(f"字典转集合：{set(my_dict)}")#仅保留Key

输出结果：

列表转集合：{1, 2, 3, 4, 5}
元组转集合：{1, 2, 3, 4, 5}
字符串转集合：{'e', 'a', 'c', 'd', 'b', 'g', 'f'}
集合转集合：{1, 2, 3, 4, 5}
字典转集合：{'key5', 'key4', 'key3', 'key1', 'key2'}

有 dict() 函数，但无法将列表、元组、字符串、集合转换成字典，因为没有键值对这样的条件。字典可以转成其余四个类型，就是可能会丢失 Value。

(4) 容器通用排序功能

sorted(容器，[reverse = True])
将给定容器进行排序，排序结果放入列表。
正向排序只需第一个参数，反向排序还需要第二个参数 reverse = True。

my_list = [3, 1, 2, 5, 4]
my_tuple = (3, 1, 2, 5, 4)
my_str = "bdcefga"
my_set = {3, 1, 2, 5, 4}
my_dict = {"key3": 1, "key1": 2, "key2": 3, "key5": 4, "key4": 5}
print(f"列表对象的排序结果：{sorted(my_list)}")
print(f"元组对象的排序结果：{sorted(my_tuple)}")
print(f"字符串对象的排序结果：{sorted(my_str)}")
print(f"集合对象的排序结果：{sorted(my_set)}")
print(f"字典对象的排序结果：{sorted(my_dict)}")#丢失Value

输出结果：

列表对象的排序结果：[1, 2, 3, 4, 5]
元组对象的排序结果：[1, 2, 3, 4, 5]
字符串对象的排序结果：['a', 'b', 'c', 'd', 'e', 'f', 'g']
集合对象的排序结果：[1, 2, 3, 4, 5]
字典对象的排序结果：['key1', 'key2', 'key3', 'key4', 'key5']