Python 中的 5 种数据容器：列表、元组、字符串、集合和字典

2.2 列表下标索引

列表中的元素都有自己的序号，是递增的，我们称之为下标索引。

我们只需要按照下标索引，即可取得对应位置的元素。从零开始计数。可以分为正向和反向两种获取方式。同时列表可以嵌套。

正向

# 语法：列表 [下标索引]
name_list = ['Tom', 'Lily', 'Rose'] 
print(name_list[0]) # 结果：Tom 
print(name_list[1]) # 结果：Lily 
print(name_list[2]) # 结果：Rose

反向

# 反向下标 从右到左 -1、-2、-3 递减
lst = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24] 
print(lst[-1]) # 结果 24 
print(lst[-2]) # 结果 23 
print(lst[-3]) # 结果 22

嵌套列表

# 定义一个嵌套列表
lst =[[1,2,3],[4,5,6],[7,8]] 
# 访问嵌套列表中的元素
print(lst[1][1]) # [4,5,6] 中的 5 
print(lst[0][-1]) # [1,2,3] 中的 3

2.3 列表常用方法

函数是一个封装的代码单元，可以提供特定功能。

在 Python 中，如果函数 class 的成员，那么函数会称之为方法。

方法和函数功能一样有传入参数，有返回值，只有方法的格式不同。

1. 查找某元素的下标

查找指定元素在列表的下标，如果找不到，报错 ValueError。

列表.index(元素)

index 就是列表对象（变量）内置的方法（函数）

my_list = ["example", "demo", "python"] 
print(my_list.index("demo")) # 结果：1

2. 列表的查找与判断

lst = ['demo', 'example', 'python', '666'] 
# 查找元素下标，找不到会报错
print(lst.index("666")) 
# 快捷操作：确定某个元素是否在列表内（找不到不报错）
# 元素 in 列表变量
# 在里面返回 True，不在里面返回 False
print("666" in lst)

3. 修改特定位置的元素值

语法：列表[下标]=值

可以使用如下语法，直接对指定下标（正向、反向下标均可）的值进行重新赋值（修改）

my_list = [1, 2, 3] 
my_list[0] = 5 
print(my_list) # 结果：[5, 2, 3]

my_list = [1, 2, 3] 
my_list[-3] = 5 
print(my_list) # 结果：[5, 2, 3]

4. 插入元素

语法：列表.insert(下标，元素），在指定的下标位置，插入插入指定的元素

my_list = [1, 2, 3] 
my_list.insert(1, "item") 
print(my_list) # 结果：[1, "item", 2, 3]

当下标值超过列表的索引范围，相当于在尾部新增一个元素

lst.insert(10, '666') # 下标超出范围时，会自动插入到列表末尾
print(lst) # 输出：[1, 'demo', 2, 3, 'item', '666']

5. 追加元素

列表.append(元素)，将指定元素追加到列表的尾部

my_list = [1, 2, 3] 
my_list.append(4) 
print(my_list) # 结果：[1, 2, 3, 4] 
my_list = [1, 2, 3] 
my_list.append([4, 5, 6]) 
print(my_list) # 结果：[1, 2, 3, [4, 5, 6]]

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

my_list = [1, 2, 3] 
my_list.extend([4, 5, 6]) 
print(my_list) # 结果：[1, 2, 3, 4, 5, 6]

6. 删除元素

**语法 1：**del 列表[下标]

**语法 2：**列表.pop(下标)

my_list = [1, 2, 3] 
# 方式 1：使用 del
del my_list[0] 
print(my_list) # 结果：[2, 3] 
# 方式 2：使用 pop()
my_list.pop(0) 
print(my_list) # 结果：[2, 3]

# 在列表尾部新增元素
# 语法：列表变量.append(元素)
lst = [1, 2, 3] 
lst.append(4) 
lst.append(5) 
lst.append(6) 
print(lst) # 输出：[1, 2, 3, 4, 5, 6] 
# 在列表尾部新增一批元素（将其它数据容器追加到当前列表尾部）
# 语法：列表变量.extend(数据容器)
lst = [1, 2, 3] 
lst.extend([4, 5, 6]) 
print(lst) # 输出：[1, 2, 3, 4, 5, 6]

7. 删除元素

语法：列表.remove(元素)

my_list = [1, 2, 3, 2, 3] 
my_list.remove(2) 
print(my_list) # 结果：[1, 3, 2, 3]

# 删除列表元素
# 方式 1 del 列表 [下标]
lst = [1, 2, 3, 4, 5, 6] 
del lst[0] 
print(lst) # 输出：[2, 3, 4, 5, 6] 
# 方式 2 列表.pop(下标)
# 和方式 1 的区别是 pop 有返回值，返回的是：被删除的元素
deleted_data = lst.pop(2) 
print("被删除的是：", deleted_data) # 输出：被删除的是：5 
print(lst) # 输出：[2, 3, 6] 
# 删除某元素在列表中的第一个匹配项
# 语法：列表.remove(元素)
lst = ["demo", "example", "example", "python", "666"] 
lst.remove("example") 
print(lst) # 输出：['demo', 'example', 'python', '666'] 
lst.remove("xxx") # 报错：ValueError: list.remove(x): x not in list
print(lst)

8. 清空列表内容

语法：列表.clear()

my_list = [1, 2, 3] 
my_list.clear() 
print(my_list) # 结果：[]

# 方式 1
lst = [1, 2, 3, 4, 5, 6] 
lst.clear() 
print(lst) # 输出：[] 
# 方式 2
lst = [1, 2, 3, 4, 5, 6] 
lst = [] 
print(lst) # 输出：[]

9. 统计某元素在列表内的数量

语法：列表.count(元素)

my_list = [1, 1, 1, 2, 3] 
print(my_list.count(1)) # 结果：3

10. 总结

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

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

列表常用操作速查表

2.4 列表的遍历

将容器内的元素依次取出进行处理的行为，称之为遍历、迭代。

使用 while 循环遍历

index = 0 # 控制因子
while index < len(列表):
    元素 = 列表 [index] # 对元素进行处理
    index += 1 # 因子更新

lst = [1, 3, 5, 7, 9] 
index = 0 
while index < len(lst):
    print(lst[index]) # 依次输出：1, 3, 5, 7, 9
    index += 1

使用 for 循环遍历

思路：直接从列表中取出元素，代码更简洁，更适合遍历数据容器。

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

lst = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] 
for i in lst:
    print(i) # 依次输出：1, 2, ..., 10

3 元组

• 列表的特点：可以修改。如果希望传递的信息不被篡改，列表就不合适了。
• 元组的特点：和列表一样，可以封装多个、不同类型的元素。
• 元组与列表的最大区别：元组一旦定义完成，就不可修改。
• 元组的适用场景：当我们需要在程序内封装数据，又不希望封装的数据被篡改时，元组就非常合适了。

3.1 元组的定义

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

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

代码示例

# 字面量
(1, 3, 5, "haha") 
# 变量
t1 = (1, 2, 3, "6") 
print(t1, "类型：", type(t1)) #(1, 2, 3, '6') 类型：<class 'tuple'> 
# 得到空元组
t1 = () 
t2 = tuple() 
print(type(t1), type(t2)) #<class 'tuple'> <class 'tuple'> 
# 只有 1 个元素的元组（特殊写法）
t1 = (1,) 
print(type(t1)) #<class 'tuple'> 
# 定义一个嵌套元组
t1 = ( (1, 2, 3), (4, 5, 6) ) 
print(t1[0][0]) # 结果：1

尝试修改元组

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

报错信息：

Traceback (most recent call last): File "D:\python-learn\05_数据容器\test.py", line 3, in <module> t1[0] = 5 TypeError: 'tuple' object does not support item assignment

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

代码示例：

# 尝试修改元组内容
t1 = (1, 2, ['item', 'demo']) 
t1[2][1] = 'best' 
print(t1) # 结果：(1, 2, ['item', 'best'])

为什么这个可以修改呢？ 答：因为这是对元组内的某个元素进行重新赋值

元组的'不可变'是指元组本身的元素不可变，如果元素是列表这种可变对象，我们依然可以修改列表内部的内容，因为这并没有改变元组里存的那个指针。

1. 元组的定义方式

(元素，元素，元素， ......)

2. 元组的操作方法

3. 元组的注意事项

• 不可修改内容（可以修改内部 list 的内部元素）

4. 元组的特点

• 和 list 基本相同（有序、任意数量元素、允许重复元素），唯一不同在于不可修改。
• 支持 for 循环

3.2 重新认识字符串

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

字符串是字符的容器，一个字符串可以存放任意数量的字符。

如，字符串："example"

1. 下标索引

字符串和列表、元组一样，也可以通过下标来访问其中的字符。

name = "example" 
print(name[0]) # 结果：i 
print(name[-1]) # 结果：a

• 修改：无法直接修改指定下标的字符（如 字符串[0] = "a" ）
• 移除：无法移除指定下标的字符（如 del 字符串[0] 、字符串.remove() 、字符串.pop() ）
• 追加：无法直接在字符串末尾追加字符（如 字符串.append() ）

如果必须对字符串进行修改，只能生成一个新的字符串，旧的字符串本身不会被改变。

2. 字符串的分割

语法：字符串.split(分隔符字符串)

功能：按照指定的分隔符字符串，将字符串划分为多个字符串，并存入列表对象中

注意：字符串本身不变，而是得到了一个列表对象

name = "传智播客 传智教育 黑马程序员 博学谷"
name_list = name.split(" ") 
print(name_list) # 结果：['传智播客', '传智教育', '黑马程序员', '博学谷'] 
print(type(name_list)) # 结果：<class 'list'>

代码样例

# 字符串分割
s = "周杰伦 | 王力宏 | 刘德滑"
lst = s.split("|") 
print("字符串本身：", s) 
print("分隔后：", lst, type(lst))

字符串本身：周杰伦 | 王力宏 | 刘德滑
分隔后：['周杰伦', '王力宏', '刘德滑'] <class 'list'>

1. 字符串本身不变：原字符串 s 的值没有被修改，这符合字符串不可变的特性。
2. 分割生成新列表：split("|") 方法会把原字符串按 | 切分成多个子字符串，然后打包成一个新的列表返回。
3. 返回类型是列表：type(lst) 显示结果为 <class 'list'> ，说明分割操作成功生成了一个列表对象。

3. 字符串规整操作

语法：字符串.strip()

功能：去除字符串首尾的空格、换行符 \n、制表符 \t 等空白字符，返回一个新字符串，原字符串不变。

代码示例：

my_str = " example and demo " 
print(my_str.strip()) # 结果："example and demo"

# strip() 去除字符串的前后空格和回车符
# 原有字符串不会被修改，而是返回一个新的
s = " \nexample666\n " 
s2 = s.strip() 
print(s2) # 结果："example666"

进阶用法：去除前后指定字符

语法：字符串.strip(字符串)

功能：去除字符串首尾的指定字符。注意：传入的字符串会被拆成单个字符，只要是其中任何一个字符都会被移除。

my_str = "12example and demo21" 
print(my_str.strip("12")) # 结果："example and demo"

# strip(字符串) 去除字符串中前后指定的字符
s = "|||example666|||" 
s2 = s.strip("|") 
print(s2) # 结果："example666"

4. 统计字符串的长度

语法：len(字符串)

说明：数字、字母、符号、空格、中文等，都算作 1 个字符。

my_str = "1234 abcd !@#$ 黑马程序员" 
print(len(my_str)) # 结果：20

统计指定子串出现的次数

语法：字符串.count(子串)

# 统计字符串有多少个 a
# count(字符串) 统计字符串内有多少个指定的子串
s = "example a a a a a a a" 
num = s.count("a") 
print(num) # 结果：8

5. 字符串的遍历

同列表、元组一样，字符串也支持 while 循环和 for 循环进行遍历。

while 循环遍历

my_str = "黑马程序员" 
index = 0 
while index < len(my_str):
    print(my_str[index])
    index += 1

for 循环遍历

my_str = "黑马程序员" 
for i in my_str:
    print(i)

6. 总结

字符串常用操作速查表

作为容器字符串的特点：

• 只可以存储字符串
• 长度任意（取决于内存大小）
• 支持下标索引
• 允许重复字符串存在
• 不可以修改（增加或删除元素等）
• 支持 for 循环

4 序列

4.1 序列的定义

序列是指：内容连续、有序、可使用下标索引的一类数据容器。

列表、元组、字符串，均可以视为序列。

序列的典型特征就是：有序并可用下标索引，字符串、元组、列表均满足这个要求。

4.2 序列的切片

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

切片：从一个序列中，取出一个子序列

语法；

序列 [起始下标：结束下标：步长]

表示从序列中，从指定位置开始，依次取出元素，到指定位置结束，得到一个新序列。

参数说明

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

代码演示：

1. 字符串切片

my_str = "12345" 
new_str = my_str[::-1] # 从头（最后）开始，到尾结束，步长 -1（倒序）
print(new_str) # 结果："54321" 
new_str = my_str[:4:2] # 从头开始，到下标 4（不含）结束，步长 2
print(new_str) # 结果："13"

2. 列表切片

my_list = [1, 2, 3, 4, 5] 
new_list = my_list[1:4] # 下标 1 开始，下标 4（不含）结束，步长 1
print(new_list) # 结果：[2, 3, 4] 
new_list = my_list[::2] # 从头开始，到最后结束，步长 2
print(new_list) # 结果：[1, 3, 5] 
new_list = my_list[3:1:-1] # 从下标 3 开始，到下标 1（不含）结束，步长 -1（倒序）
print(new_list) # 结果：[4, 3] 
lst = ["aa", "bb", 3, 5, 6] 
print(lst[1:3]) # 取出 "bb", 3 → 结果：['bb', 3] 
print(lst[-2:-5:-1]) # 取出 5, 3, "bb" → 结果：[5, 3, 'bb']

3. 元组切片

my_tuple = (1, 2, 3, 4, 5) 
new_tuple = my_tuple[:] # 从头开始，到最后结束，步长 1
print(new_tuple) # 结果：(1, 2, 3, 4, 5) 
new_tuple = my_tuple[:1:-2] # 从头（最后）开始，到下标 1（不含）结束，步长 -2（倒序）
print(new_tuple) # 结果：(5, 3)

4. 总结

• 切片操作对列表、元组、字符串是完全通用的。
• 非常灵活，起始位置、结束位置、步长（正序 / 反序）都可以自行控制。
• 切片返回的是一个新的序列，不会修改原序列。

5 集合

我们目前已经接触了列表、元组、字符串三个数据容器，基本满足大多数使用场景。但它们都有一个明显的局限：都支持重复元素且是有序的。

当业务场景需要对内容进行去重处理时，列表、元组、字符串就不方便了。

而集合（Set）的主要特点就是：

• 不支持元素重复（自带去重功能）
• 内容无序

列表、元组、字符串特性对比表

5.1 基本语法

# 定义集合字面量 {元素，元素，......, 元素}
# 定义集合变量 变量名称 = {元素，元素，......, 元素}
# 定义空集合 变量名称 = set()

不同容器的定义符号对比

• 列表使用：[]
• 元组使用：()
• 字符串使用：""
• 集合使用：{}

5.2 集合的操作

# 字面量
{1, 3, 5, "哈哈", True, 3, 5} 
# 变量
set1 = {1, 3, 5, "哈哈", True, 3, 5} 
# 去重
# 空集合
set2 = set() 
print(set1, type(set1)) #{1, 3, 5, '哈哈', True} <class 'set'> 
print(set2, type(set2)) #set() <class 'set'> 
# 去重且无序
set3 = {"bbb", "bbb", "aaa", "ccc"} 
print(set3) #{'aaa', 'bbb', 'ccc'}

知识点

• 首先，因为集合是无序的，所以集合不支持：下标索引访问
• 但是集合和列表一样，是允许修改的，所以我们来看看集合的修改方法。
• 添加新元素
  • 语法：集合.add (元素)：将指定元素，添加到集合内
  • 结果：集合本身被修改，添加了新元素

1. 添加元素

my_set = {"Hello", "World"} 
my_set.add("item") 
print(my_set) # 结果：{'Hello', 'item', 'World'} 集合是无序

2. 移除元素

# remove(元素) 移除指定元素
my_set.remove("d") 
print(my_set)

3. 随机取出元素

# 从集合中随机取出元素
# 语法：集合.pop()，功能：从集合中随机取出一个元素
# 结果：会得到一个元素的结果，同时集合本身被修改，元素被移除
my_set = {"Hello", "world", "item"} 
element = my_set.pop() 
print(my_set) # 结果：{'world', 'item'} 
print(element) # 结果：'Hello'

4. 清空集合 clear()

# 清空集合
my_set.clear() 
# my_set = set()
print(my_set) # 结果：set()

5. 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 不变

# 2 个集合的并集，合并
# set1.union(set2) 2 个集合合并为 1 个
# 结果：原有 set1、set2 不变，得到新的集合
set1 = {1, 2, 3} 
set2 = {1, 4, 5} 
set3 = set1.union(set2) 
print("合并后：", set3) 
print("原有 set1：", set1) 
print("原有 set2：", set2)

6. 查看集合的元素数量

• 语法：len(集合)
• 功能：统计集合内有多少元素
• 结果：得到一个整数结果

set1 = {1, 2, 3} 
print(len(set1)) # 结果：3

my_set = {"c", "a", "b", "c"} 
# 统计元素数量，len(集合)
print(len(my_set)) # 结果：3（因为集合自动去重）

7. 集合的遍历

• 集合支持 for 循环遍历
• 集合不支持下标索引，因此不支持 while 循环

# 集合同样支持 for 循环遍历
set1 = {1, 2, 3} 
for i in set1:
    print(i) # 结果
    # 1
    # 2
    # 3

5.3 总结

集合常用操作速查表

集合:

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

6 字典

6.1 字典的定义

基本语法

字典使用 {} 定义，但存储的是一个个键值对：

# 定义字典字面量 {key: value, key: value, ......, key: value}
# 定义字典变量 my_dict = {key: value, key: value, ......, key: value}
# 定义空字典 my_dict = {} # 空字典定义方式 1
my_dict = dict() # 空字典定义方式 2

核心特点

• 使用 {} 存储数据，每一个元素是一个键值对
• 每一个键值对包含 Key 和 Value（用冒号 : 分隔）
• 键值对之间使用逗号 , 分隔
• Key 和 Value 可以是任意类型的数据（key 不可为字典）
• Key 不可重复，重复会对原有数据进行覆盖

# 前文记录学生成绩的需求，可以如下记录：
stu_score = {"王力鸿": 99, "周杰伦": 88, "林俊节": 77}

1. 空字典定义

# 空字典
d = {} 
print(type(d)) # 打印结果：<class 'dict'> 
d = dict() 
print(type(d)) # 打印结果：<class 'dict'>

2. 字典字面量与变量

# 字面量
{"周杰伦": 99, "王力鸿": 88, "林军杰": 77} 
# 变量
d = {"周杰伦": 99, "王力鸿": 88, "林军杰": 77, 0: 66}

3. 键（Key）不可重复

# 字典的 key 是不可以重复的
d = {"周杰伦": 99, "王力鸿": 88, "林军杰": 77, "林军杰": 66} 
# 打印出来后，第二个林军杰覆盖第一个林军杰
print(d)

4. 嵌套字典（记录学生成绩）

stu_score = {
 "王力鸿": {"语文": 77, "数学": 66, "英语": 33}, 
 "周杰伦": {"语文": 88, "数学": 86, "英语": 55}, 
 "林俊节": {"语文": 99, "数学": 96, "英语": 66}
}

5. 嵌套字典的内容获取

stu_score = {
 "王力鸿": {"语文": 77, "数学": 66, "英语": 33}, 
 "周杰伦": {"语文": 88, "数学": 86, "英语": 55}, 
 "林俊节": {"语文": 99, "数学": 96, "英语": 66}
}
print(stu_score["王力鸿"]) # 结果：{"语文": 77, "数学": 66, "英语": 33}
print(stu_score["王力鸿"]["语文"]) # 结果：77
print(stu_score["周杰伦"]["数学"]) # 结果：86

6. 字典中 Value 为列表的示例

d = {
 "周杰伦": ["唱", "跳", "rap"], 
 "林军杰": ["吃", "喝", "玩"], 
 "王力鸿": ["睡", "呆", "憨"]
}
# 查看王力鸿的爱好
print(d["王力鸿"]) 
# 查看王力鸿的爱好 2
print(d["王力鸿"][1])

6.2 字典的操作

注意事项

• 键值对的 Key 和 Value 可以是任意类型（Key 不可为字典）
• 字典内 Key 不允许重复，重复添加等同于覆盖原有数据
• 字典不可用下标索引，而是通过 Key 检索 Value

1. 字典的新增与更新

# 语法：字典 [Key] = Value，结果：字典被修改，新增了元素
stu_score = {
 "王力鸿": 77, 
 "周杰伦": 88, 
 "林俊节": 99
}
# 新增：张学渣的考试成绩
stu_score["张学渣"] = 66 
print(stu_score) # 结果：{'王力鸿': 77, '周杰伦': 88, '林俊节': 99, '张学渣': 66}

2. 更新元素

# 语法：字典 [Key] = Value，结果：字典被修改，元素被更新
# 注意：字典 Key 不可以重复，所以对已存在的 Key 执行上述操作，就是更新 Value 值
stu_score = {
 "王力鸿": 77, 
 "周杰伦": 88, 
 "林俊节": 99
}
# 更新：王力鸿的考试成绩
stu_score["王力鸿"] = 100 
print(stu_score) # 结果：{'王力鸿': 100, '周杰伦': 88, '林俊节': 99}

3. 字典的删除

# 语法：字典.pop(Key)，结果：获得指定 Key 的 Value，同时字典被修改，指定 Key 的数据被删除
stu_score = {
 "王力鸿": 77, 
 "周杰伦": 88, 
 "林俊节": 99
}
value = stu_score.pop("王力鸿") 
print(value) # 结果：77
print(stu_score) # 结果：{'周杰伦': 88, '林俊节': 99}

4. 清空字典

# 语法：字典.clear()，结果：字典被修改，元素被清空
stu_score = {
 "王力鸿": 77, 
 "周杰伦": 88, 
 "林俊节": 99
}
stu_score.clear() 
print(stu_score) # 结果：{}

5. 获取全部 Key

# 语法：字典.keys()，结果：得到字典中的全部 Key
stu_score = {
 "王力鸿": 77, 
 "周杰伦": 88, 
 "林俊节": 99
}
keys = stu_score.keys() 
print(keys) # 结果：dict_keys(['王力鸿', '周杰伦', '林俊节'])

6. 遍历字典

# 方式 1：通过 keys()
stu_score = {
 "王力鸿": 77, 
 "周杰伦": 88, 
 "林俊节": 99
}
keys = stu_score.keys() 
for key in keys:
    print(f"学生:{key}, 分数:{stu_score[key]}") 
# 方式 2：直接遍历字典（可读性好）
for key in stu_score.keys():
    print(f"{key}: {stu_score[key]}") 
# 方式 3：直接对字典 for x in 字典，得到的就是 key
for key in stu_score:
    print(f"{key}: {stu_score[key]}")

7. 获取字典长度

# 语法：len(字典)
print(len(stu_score)) # 结果：3

6.3 总结

字典特征：

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

数据容器分类：

1. 是否支持下标索引

• 支持：列表、元组、字符串 → 序列类型
• 不支持：集合、字典 → 非序列类型

2. 是否支持重复元素

• 支持：列表、元组、字符串 → 序列类型
• 不支持：集合、字典 → 非序列类型

3. 是否可以修改

• 支持：列表、集合、字典
• 不支持：元组、字符串

6.4 练习案例

解答：

d = {
 "王力鸿": {"部门": "科技部", "工资": 3000, "级别": 1}, 
 "周杰伦": {"部门": "市场部", "工资": 5000, "级别": 2}, 
 "林军杰": {"部门": "市场部", "工资": 7000, "级别": 3}, 
 "张学油": {"部门": "科技部", "工资": 4000, "级别": 1}, 
 "刘德滑": {"部门": "市场部", "工资": 6000, "级别": 2}
}
print(f"更新前：\n{d}") 
for k in d:
    if d[k]["级别"] == 1: # 更新工资
        d[k]["工资"] = d[k]["工资"] + 1000 
        # 更新级别
        d[k]["级别"] = 2 
print(f"更新后：\n{d}")

7 总结

容器对比：

• 列表：一批数据，可修改、可重复的存储场景
• 元组：一批数据，不可修改、可重复的存储场景
• 字符串：一串字符串的存储场景
• 集合：一批数据，去重存储场景
• 字典：一批数据，可用 Key 检索 Value 的存储场景

1 遍历操作

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

遍历支持情况

• 类数据容器（列表、元组、字符串、集合、字典）都支持 for 循环遍历
• 列表、元组、字符串支持 while 循环（因为支持下标索引）
• 集合、字典不支持 while 循环（因为无法使用下标索引）

2. 通用统计功能

3. 容器的通用转换

lst = [1, 3, 5, 7, 9] 
t = (1, 3, 5, 7, 9) 
s_str = "itheima" 
s_set = {1, 3, 5, 7, 9} 
d = {"1": 11, "2": 22, "3": 33} 
# 转字符串
print("*"*50) # 输出：**************************************************
print(f"{lst} 转 str： {str(lst)}") # 输出：[1, 3, 5, 7, 9] 转 str： [1, 3, 5, 7, 9]
print(f"{t} 转 str： {str(t)}") # 输出：(1, 3, 5, 7, 9) 转 str： (1, 3, 5, 7, 9)
print(f"{s_set} 转 str： {str(s_set)}") # 输出：{1, 3, 5, 7, 9} 转 str： {1, 3, 5, 7, 9}
print(f"{d} 转 str： {str(d)}") # 输出：{'1': 11, '2': 22, '3': 33} 转 str： {'1': 11, '2': 22, '3': 33}
# 转集合
print("*"*50) # 输出：**************************************************
print(f"{lst} 转 set： {set(lst)}") # 输出：[1, 3, 5, 7, 9] 转 set： {1, 3, 5, 7, 9}
print(f"{t} 转 set： {set(t)}") # 输出：(1, 3, 5, 7, 9) 转 set： {1, 3, 5, 7, 9}
print(f"{s_str} 转 set： {set(s_str)}") # 输出：itheima 转 set： {'m', 'i', 't', 'h', 'e', 'a'}
print(f"{d} 转 set： {set(d)}") # 输出：{'1': 11, '2': 22, '3': 33} 转 set： {'1', '2', '3'}
# 转列表
print(f"{t} 转 list： {list(t)}") # 输出：(1, 3, 5, 7, 9) 转 list： [1, 3, 5, 7, 9]
print(f"{s_str} 转 list： {list(s_str)}") # 输出：itheima 转 list： ['i', 't', 'h', 'e', 'i', 'm', 'a']
print(f"{s_set} 转 list： {list(s_set)}") # 输出：{1, 3, 5, 7, 9} 转 list： [1, 3, 5, 7, 9]
print(f"{d} 转 list： {list(d)}") # 输出：{'1': 11, '2': 22, '3': 33} 转 list： ['1', '2', '3']

4. 通用排序功能

sorted(容器，[reverse=True])

将给定容器进行排序。

排序后会变成列表

# 排序
lst = [5, 3, 1, 7, 2] 
t = (5, 3, 1, 7, 2) 
s_str = "itheima" 
s_set = {5, 3, 1, 7, 2} 
d = {"33": 11, "cc": 22, "bb": 33} 
print("*"*50) # 输出：**************************************************
print(f"{lst}, 排序后：{sorted(lst)}") # 输出：[5, 3, 1, 7, 2], 排序后：[1, 2, 3, 5, 7]
print(f"{t}, 排序后：{sorted(t)}") # 输出：(5, 3, 1, 7, 2), 排序后：[1, 2, 3, 5, 7]
print(f"{s_str}, 排序后：{sorted(s_str)}") # 输出：itheima, 排序后：['a', 'e', 'h', 'i', 'i', 'm', 't']
print(f"{s_set}, 排序后：{sorted(s_set)}") # 输出：{1, 2, 3, 5, 7}, 排序后：[1, 2, 3, 5, 7]
print(f"{d}, 排序后：{sorted(d)}") # 输出：{'33': 11, 'cc': 22, 'bb': 33}, 排序后：['33', 'bb', 'cc'] （按 key 排序并且仅剩余 key 转为 list）
# 降序排序 reverse=True
print("*"*50) # 输出：**************************************************
print(f"{lst}, 排序后 (reverse=True): {sorted(lst, reverse=True)}") # 输出：[5, 3, 1, 7, 2], 排序后 (reverse=True): [7, 5, 3, 2, 1] （转为 list）
print(f"{t}, 排序后 (reverse=True): {sorted(t, reverse=True)}") # 输出：(5, 3, 1, 7, 2), 排序后 (reverse=True): [7, 5, 3, 2, 1] （转为 list）
print(f"{s_str}, 排序后 (reverse=True): {sorted(s_str, reverse=True)}") # 输出：itheima, 排序后 (reverse=True): ['t', 'm', 'i', 'i', 'h', 'e', 'a']
print(f"{s_set}, 排序后 (reverse=True): {sorted(s_set, reverse=True)}") # 输出：{1, 2, 3, 5, 7}, 排序后 (reverse=True): [7, 5, 3, 2, 1] （转为 list）
print(f"{d}, 排序后 (reverse=True): {sorted(d, reverse=True)}") # 输出：{'33': 11, 'cc': 22, 'bb': 33}, 排序后 (reverse=True): ['cc', 'bb', '33'] （按 key 排序并且仅剩余 key 转为 list）

5. 找最值

lst = [1, 3, 5, 7, 9] 
t = (1, 3, 5, 7, 9) 
s_str = "itheima" 
s_set = {1, 3, 5, 7, 9} 
d = {"1": 11, "2": 22, "3": 33} 
# 找出最大值
print(f"{lst}, max: {max(lst)}") # 输出：[1, 3, 5, 7, 9], max: 9
print(f"{t}, max: {max(t)}") # 输出：(1, 3, 5, 7, 9), max: 9
print(f"{s_str}, max: {max(s_str)}") # 输出：itheima, max: t
print(f"{s_set}, max: {max(s_set)}") # 输出：{1, 3, 5, 7, 9}, max: 9
print(f"{d}, max: {max(d)}") # 输出：{'1': 11, '2': 22, '3': 33}, max: 3
# 找出最小值
print(f"{lst}, min: {min(lst)}") # 输出：[1, 3, 5, 7, 9], min: 1
print(f"{t}, min: {min(t)}") # 输出：(1, 3, 5, 7, 9), min: 1
print(f"{s_str}, min: {min(s_str)}") # 输出：itheima, min: a
print(f"{s_set}, min: {min(s_set)}") # 输出：{1, 3, 5, 7, 9}, min: 1
print(f"{d}, min: {min(d)}") # 输出：{'1': 11, '2': 22, '3': 33}, min: 1

6. 字符串比较

中文:

比较完全记不住，因为中文字多，每一个字在编码表内对应数字，靠数字比较。

英文：

• 小写字母>大写，大写字母>数字 其余查询 ASCII 码表 字符串在存储上都是依靠码表存储

数字：

小写字母>大写，大写字母>数字 其余查询 ASCII 码表 字符串在存储上都是依靠码表存储对应数字：

• 英文、数字、符号等，依靠 ASCII 码表，对应数字存储
• 中文，依靠 UTF8 或 GBK 等码表，对应数字存储 存的是数字，显示是字符 字符串比较是按位比较（逐位比较），比较其存储的真实数字大小
• 从左到右 一个位一个位比较
• 有内容是大于空的

print("a" > "A") # 输出：True
print("A" > "!") # 输出：True
# 有内容大于空，即 d 大于空，则 abcd 大
print("abc" > "abcd") # 输出：False
# 2 大，第一位"2"是大于"1"
print("123" > "2") # 输出：False
# 中文也能比较大小，依靠编码表（一般是 UTF8 或 GBK）
print("黑" > "马") # 输出：False