1. 数据容器入门

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

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

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

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

2. list（列表）

2.1 列表的定义

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

基本语法：

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

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

# 一次存储多个数据
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))
1
2
3
4
5
6
7
8
9
10
11
12

输出结果：

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

2.2 列表的下标索引

2.2.1 列表的正向索引

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

输出结果：

tom
jerry
jack
1
2
3

2.2.2 列表的反向索引

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

输出结果：

jack
jerry
tom
1
2
3

2.2.3 嵌套列表同样支持索引

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

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

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

2.3 列表的常用操作 / 方法

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

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

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

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

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

输出结果：

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

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

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

输出结果：

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

(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
5
6
7

输出结果：

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

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

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

输出结果：

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

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

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

输出结果：

[2, 3]
1

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

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

输出结果：

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

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

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

输出结果：

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

(8) clear: 清空列表内容

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

输出结果：

[]
1

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

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

输出结果：

3
1

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

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

输出结果：

5
1

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

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

2.4 列表的循环遍历

2.4.1 while 循环遍历列表

基本语法：

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

【例】

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
5
6
7

输出结果：

1
2
3
4
1
2
3
4

2.4.2 for 循环遍历列表

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

基本语法：

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

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

【例】

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

输出结果：

1
2
3
4
1
2
3
4

while 循环和 for 循环对比：

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

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

3. tuple（元组）

3.1 元组的定义

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

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

  #定义元组字面量
  (元素, 元素, ..., 元素)
  
  # 定义元组变量
  变量名称 = (元素, 元素, ..., 元素)
  
  #定义空元组
  #方式1
  变量名称 = ()
  #方式2
  变量名称 = tuple()
  1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11

  【例】

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

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

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

  输出结果：

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

• 元组支持嵌套

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

  输出结果：

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

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

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

  输出结果：

  5
  1

3.2 元组的操作 / 方法

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

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

输出结果：

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

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

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

元组的多数特性与列表（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}")
1
2
3
4
5
6
7
8

输出结果：

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

3.3 元组的遍历

while 循环：

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

for 循环：

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

上面两份代码都输出：

tom
jerry
jack
smith
1
2
3
4

3.4 元组注意事项

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

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

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

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

输出结果：

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

4. str（字符串）

4.1 字符串的定义

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

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

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

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

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

4.2 字符串的常用操作

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

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

(2) replace：字符串的替换

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

输出结果：

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

(3) split：字符串的分割

my_str = "hello python itheima itcast"
my_list = my_str.split(" ")
print(my_str)
print(my_list)
print(type(my_list))
1
2
3
4
5

输出结果：

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

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

• 去前后空格、tab、换行

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

• 去前后指定字符串

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

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

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

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

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

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

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

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

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

4.3 字符串的遍历

while 循环：

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

for 循环：

my_str = "hello"
for ch in my_str:
    print(ch)
1
2
3

【例】给定一个字符串：“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("|"))
1
2
3
4
5

输出结果：

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

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)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

【例】有字符串："万过薪月，员序程马黑来，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)
1
2
3
4
5
6
7
8
9
10

6. set（集合）

6.1 集合的定义

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

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

在此总结一下前面所学容器使用的符号：
(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))
1
2
3
4

输出结果：

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

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

6.2 集合的操作 / 方法

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

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

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

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

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

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

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

(4) clear：清空集合

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

(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]不变
1
2
3
4
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]
1
2
3
4
5

(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不变
1
2
3
4
5
6

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

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

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

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

6.3 集合的遍历

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

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

【例】有如下列表对象：
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()
1
2
3
4
5
6
7
8
9
10
11

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

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

输出结果：

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

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

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

输出结果：

99
88
77
1
2
3

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

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

my_dict = {
    "tom":{
        "语文":77,
        "数学":88,
        "英语":99
    },
    "jerry":{
        "语文":99,
        "数学":88,
        "英语":77
    },
    "jack":{
        "语文":88,
        "数学":99,
        "英语":77
    }
}
print(my_dict)
print(f'tom的语文成绩是：{my_dict["tom"]["语文"]}')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

7.2 字典的操作 / 方法

（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)
1
2
3
4
5

输出结果：

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

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

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

输出结果：

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

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

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

输出结果：

{}
1

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

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

输出结果：

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

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

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

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

• 可以容纳多个数据
• 可以容纳不同类型的数据
• 每一份数据是 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])
1
2
3
4

输出结果：

tom 99
jerry 88
jack 77
1
2
3

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

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

输出结果：

tom 99
jerry 88
jack 77
1
2
3

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

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

9. 数据容器的通用操作

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

(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串的最大最小值
1
2
3
4
5
6
7
8
9
10

输出结果：

5 5 1
5 5 1
7 g a
5 5 1
5 key5 key1
1
2
3
4
5

(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
6
7
8
9
10

输出结果：

列表转列表：[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']
1
2
3
4
5

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
6
7
8
9
10

输出结果：

列表转元组：(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')
1
2
3
4
5

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
6
7
8
9
10

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

列表转字符串：[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}
1
2
3
4
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
6
7
8
9
10

输出结果：

列表转集合：{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'}
1
2
3
4
5

有 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
6
7
8
9
10

输出结果：

列表对象的排序结果：[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']
1
2
3
4
5