python入门(六)——python数据容器

系列文章目录

python入门(一)——你好python
python入门(二)——python基础语法
python入门(三)——python判断语句
python入门(四)——python循环语句
python入门(五)——python函数
python入门(七)——python函数进阶

---

---

1 数据容器入门

一个变量记录六份数据

name_list = ['王力宏', '周杰伦', '林俊杰', '张学友', '周星驰', '刘德华']
print(name_list)

['王力宏', '周杰伦', '林俊杰', '张学友', '周星驰', '刘德华']

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

根据是否支持重复元素、是否可以修改、是否有序等分为五类：列表list、元组tuple、字符串str、集合set、字典dict

2 数据容器：list(列表)

# 字面量
[元素1、元素2、元素3、元素4、...]

# 定义变量
变量名称 = [元素1、元素2、元素3、元素4、...]

# 定义空列表
变量名称 = []
变量名称 = list()

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

name_list = ['王力宏', 666, 'python', '张学友', '周星驰', '刘德华']
print(name_list)
print(type(name_list))

['王力宏', 666, 'python', '张学友', '周星驰', '刘德华']
<class 'list'>

列表可以一次存储多个数据，且可以是不同的数据类型，支持嵌套

name_list = [['王力宏', 666, 'python'], '张学友', '周星驰', '刘德华']
print(name_list)
print(type(name_list))

[['王力宏', 666, 'python'], '张学友', '周星驰', '刘德华']
<class 'list'>

列表的每一个元素都有其位置下表索引，从前向后的方向，从0开始，依次递增

name_list = [['王力宏', 666, 'python'], '张学友', '周星驰', '刘德华']
print(name_list[0])
print(name_list[1])
print(name_list[2])
print(name_list[3])

['王力宏', 666, 'python']
张学友
周星驰
刘德华

列表可以反向索引，从后向前依次递减（-1、-2、-3…）

name_list = [['王力宏', 666, 'python'], '张学友', '周星驰', '刘德华']
print(name_list[-4])
print(name_list[-3])
print(name_list[-2])
print(name_list[-1])

['王力宏', 666, 'python']
张学友
周星驰
刘德华

嵌套列表同样支持下标索引

name_list = [['王力宏', 666, 'python'], '张学友', '周星驰', '刘德华']
print(name_list[0][0])
print(name_list[0][1])
print(name_list[0][2])

王力宏
666
python

注意下标索引的取值范围，超出范围无法取出元素，并且会报错

列表的查询功能(方法)

如果将函数定义为class类的成员，那么函数就称之为方法

函数

def add(x, y):
	return x + y

方法

class student:
	def add(self, x, y)
		return x + y

方法和函数功能一样，有传入参数，有返回值，只是方法的使用格式不同：
函数的使用：
num = add(1, 2)
方法的使用：
student = student()
num = student.add(1, 2)

查询某元素的下标

列表.index(元素)
index是列表对象(变量)内置的方法(函数)

name_list = [['王力宏', 666, 'python'], '张学友', '周星驰', '刘德华']
print(name_list.index("张学友"))

1

修改特定位置(索引)的元素值

列表[下标] = 值

直接对指定下标的值进行重新赋值(修改)

name_list = [['王力宏', 666, 'python'], '张学友', '周星驰', '刘德华']
name_list[1] = 888
name_list[-1] = 111
print(name_list)

[['王力宏', 666, 'python'], 888, '周星驰', 111]

插入元素

列表.insert(下标, 元素)，在指定的下标位置插入指定的元素

name_list = [['王力宏', 666, 'python'], '张学友', '周星驰', '刘德华']
name_list.insert(1, "张国荣")
print(name_list)

[['王力宏', 666, 'python'], '张国荣', '张学友', '周星驰', '刘德华']

追加元素

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

name_list = [['王力宏', 666, 'python'], '张学友', '周星驰', '刘德华']
name_list.append("张国荣")
print(name_list)

[['王力宏', 666, 'python'], '张学友', '周星驰', '刘德华', '张国荣']

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

name_list = [['王力宏', 666, 'python'], '张学友', '周星驰', '刘德华']
name_list.extend(["张国荣", "邓丽君"])
print(name_list)

[['王力宏', 666, 'python'], '张学友', '周星驰', '刘德华', '张国荣', '邓丽君']

name_list = [['王力宏', 666, 'python'], '张学友', '周星驰', '刘德华']
name_list2 = ["张国荣", "邓丽君"]
name_list.extend(name_list2)
print(name_list)

[['王力宏', 666, 'python'], '张学友', '周星驰', '刘德华', '张国荣', '邓丽君']

删除元素

del 列表[下标]

name_list = [['王力宏', 666, 'python'], '张学友', '周星驰', '刘德华']
del name_list[0]
print(name_list)

['张学友', '周星驰', '刘德华']

列表.pop(下标)

name_list = [['王力宏', 666, 'python'], '张学友', '周星驰', '刘德华']
out_name = name_list.pop(1)
print(name_list)
print(f"取出的元素是：{out_name}")

[['王力宏', 666, 'python'], '周星驰', '刘德华']
取出的元素是：张学友

列表.remove(元素)
删除某元素在列表中的第一个匹配项

num1 = [1, 2, 3, 2, 3]
num1.remove(2)
print(num1)

[1, 3, 2, 3]

列表.clear()
清空列表内容

num1 = [1, 2, 3, 2, 3]
num1.clear()
print(num1)

[]

统计某个元素的数量

列表.count(元素)
统计某元素在列表内的数量

num1 = [1, 2, 3, 2, 3]
print(num1.count(3))

2

统计列表内的元素数量

len(列表)
统计列表内有多少元素

num1 = [1, 2, 3, 2, 3]
print(len(num1))

5

总结

列表特点

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

student_age = [21, 25, 21, 23, 22, 20]
student_age.append(31)
student_age.extend([29, 33, 30])
print(f"列表中取出的第一个元素是：{student_age[0]}")
print(f"列表中取出的最后一个元素是：{student_age[-1]}")
print(f"列表中元素31的下标是：{student_age.index(31)}")
print(f"最后的列表内容是：{student_age}")

列表中取出的第一个元素是：21
列表中取出的最后一个元素是：30
列表中元素31的下标是：6
最后的列表内容是：[21, 25, 21, 23, 22, 20, 31, 29, 33, 30]

3 list(列表)的遍历

while循环遍历

• 定义一个变量表示下标，从0开始
• 循环条件为 下标值<列表的元素数量

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

name_list = [['王力宏', 666, 'python'], '张学友', '周星驰', '刘德华']
index = 0
while index < len(name_list):
    name = name_list[index]
    print(name)
    index += 1
   
['王力宏', 666, 'python']
张学友
周星驰
刘德华

for循环

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

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

name_list = [['王力宏', 666, 'python'], '张学友', '周星驰', '刘德华']
for name in name_list:
    print(name)

['王力宏', 666, 'python']
张学友
周星驰
刘德华

while循环和for循环比较

循环控制：

• while循环可以自定义循环条件，并自行控制
• for循环不可以自定循环条件，只可以一个个从容器内取出数据

无限循环：

• while循环可以通过条件控制做到无限循环
• for循环理论上不可以，因为遍历的容器容量不是无限的

使用场景：

• while循环适用于任何想要循环的场景
• for循环适用于遍历数据容器的场景或简单的固定次数循环场景

总结：

• for循环更简单，while更灵活
• for用于从容器内依次取出元素并处理，while用以任何需要循环的场景

new_list = []
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
for element in my_list:
    if element % 2 == 0:
        new_list.append(element)
print(f"通过for循环，从列表:{my_list}中取出偶数，组成新列表：{new_list}")

通过for循环，从列表:[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]中取出偶数，组成新列表：[2, 4, 6, 8, 10]

new_list = []
element = 0
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
while element < len(my_list):
    my_element = my_list[element]
    if my_element % 2 == 0:
        new_list.append(my_element)
    element += 1
print(f"通过while循环，从列表:{my_list}中取出偶数，组成新列表：{new_list}")

通过while循环，从列表:[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]中取出偶数，组成新列表：[2, 4, 6, 8, 10]

4 数据容器：tuple(元祖)

元祖同列表一样，都是可以封装多个、不同类型的元素在内，最大的不同点在于元组一旦定义完成，不可修改

定义元组

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

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

注意

# 定义3个元素的元组
t1 = tuple(1, "hello", True)
# 定义1个元素的元组
t2 = ("hello", ) 
# 必须带有逗号，否则不是元组类型

注意：元组只有一个数据，则数据后面要添加逗号

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

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

元组也支持嵌套：

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

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

元组操作

t1 = (1, 2, 3, "hello", 4, 5, "hello", 3)
print(f"元素3的下标：{t1.index(3)}")
print(f"元组中hello元素出现的次数：{t1.count('hello')}")
print(f"元组含有的数量数目：{len(t1)}")

元素3的下标：2
元组中hello元素出现的次数：2
元组含有的数量数目：8

遍历的方式跟列表是一样的，for和while遍历

注意：

• 不可以修改元组的内容，否则会直接报错
• 可以修改元组内的list（修改元素、增加、删除、反转等）

t1 = (1, 2, 3, ["hello", 4, 5], "hello", 3)
t1[3][0] = "world"
print(t1)

(1, 2, 3, ['world', 4, 5], 'hello', 3)

元组特点：

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

student = ('周杰伦', 11, ['football', 'music'])
print(f"学生年龄下标位置：{student.index(11)}")
print(f"学生姓名：{student[0]}")
del student[2][0]
student[2].append('coding')
print(f"更改后的学生信息：{student}")

学生年龄下标位置：1
学生姓名：周杰伦
更改后的学生信息：('周杰伦', 11, ['music', 'coding'])

5 数据容器：str(字符串)

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

字符串的下标/索引

也可以通过下标进行访问，从前向后下标从0开始，从后向前，下标从-1开始

name = "ithemia"
print(name[0])
print(name[-1])

i
a

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

查找下标索引值

字符串.index(字符串)

name = "itheima and itcast"
print(name.index("t"))
print(name.index("and"))

1
8

字符串的替换

字符串.replace(字符串1, 字符串2)

将字符串内的全部：字符串1替换为字符串2，不是修改字符串本身，而是得到一个新字符串

name = "itheima and itcast"
new_name = name.replace("and", "or")
print(f"将{name}替换成{new_name}")

将itheima and itcast替换成itheima or itcast

字符串的分割

字符串.split(分隔符字符串)

按照指定的分割符字符串，将字符串划分为多个字符串，并存入列表对象中，字符串本身不变，而是得到一个列表对象

name = "itheima and itcast"
new_name = name.split(" ")
print(f"将{name}切割成{new_name}，类型是{type(new_name)}")

将itheima and itcast切割成['itheima', 'and', 'itcast']，类型是<class 'list'>

字符串去前后空格

字符串.strip()

不传入参数默认直接去除首尾空格

name = " itheima and itcast "
new_name = name.strip(" ")
print(f"{name}去前后空格变成：{new_name}")

 itheima and itcast 去前后空格变成：itheima and itcast

name = " itheima and itcast "
new_name = name.strip()
print(f"{name}不传入参数：{new_name}")

 itheima and itcast 不传入参数：itheima and itcast

字符串去前后制定字符

字符串.strip(字符串)

name = "12itheima and itcast21"
new_name = name.strip("12")
print(f"{name}去strip('12')变成：{new_name}")

12itheima and itcast21去strip('12')变成：itheima and itcast

注意：
传入的参数是“12”其实是**“1”和“2”都会被移除**，是按照单个字符串

统计字符串出现次数

字符串.count(字符串1)

name = "12itheima and itcast21"
print(name.count("it"))

2

字符串长度

len(字符串)

name = "12itheima and itcast21"
print(len(name))

22

常用操作汇总

字符串的遍历同上，用while和for循环
字符串的特点：

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

my_str = "itheima itcast boxuegu"
print(f"字符串{my_str}中有：{my_str.count('it')}个it字符")
new_my_str = my_str.replace(" ", "|")
print(f"字符串{my_str}，被替换空格后，结果：{new_my_str}")
print(f"字符串{new_my_str}，按照|分隔后，得到：{new_my_str.split('|')}")

字符串itheima itcast boxuegu中有：2个it字符
字符串itheima itcast boxuegu，被替换空格后，结果：itheima|itcast|boxuegu
字符串itheima|itcast|boxuegu，按照|分隔后，得到：['itheima', 'itcast', 'boxuegu']

6 数据容器(序列)的切片

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

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

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

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

• 起始下标表示从何处开始，可以留空，留空视作从头开始
• 结束下标(不含)表示何处结束，可以留空，留空视作截取到结尾
• 步长表示依次取元素的间隔
• 步长为负数，表示反向取，起始下标和结束下标也要反向标记

切片操作不会影响序列本身，而是产生新的序列

my_str = "园乐堡奇比，到来迎欢"
print(my_str[4:1:-1])
print(my_str[::-1][5:8])

比奇堡
比奇堡

7 数据容器：set(集合)

集合特点：不支持元素重复，自带去重功能，并且内容无序

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

my_set = {"姗迪", "海绵宝宝", "派大星", "蟹老板", "章鱼哥", "痞老板", "泡芙老师", "姗迪", "海绵宝宝", "派大星", "蟹老板", "章鱼哥", "痞老板", "泡芙老师"}

print(my_set)

{'章鱼哥', '泡芙老师', '痞老板', '蟹老板', '海绵宝宝', '姗迪', '派大星'}

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

添加新元素

集合.add(元素)

将指定元素添加到集合内，集合本身被修改，添加新元素

my_set = {'hello', 'world'}
my_set.add('!')
print(my_set)

{'hello', '!', 'world'}

移除元素

集合.remove(元素)

将指定元素从集合内一处，集合本身被修改，移除元素

my_set = {'hello', 'world'}
my_set.remove('hello')
print(my_set)

{'world'}

随机移除一个元素

集合.pop()

从集合中随机取出一个元素，会得到一个元素的结果，同时集合本身被修改，元素被移除

my_set = {"姗迪", "海绵宝宝", "派大星", "蟹老板", "章鱼哥", "痞老板", "泡芙老师"}
element = my_set.pop()
print(element)
print(my_set)

章鱼哥
{'姗迪', '蟹老板', '泡芙老师', '痞老板', '海绵宝宝', '派大星'}

清空集合

集合.clear()

my_set = {"姗迪", "海绵宝宝", "派大星", "蟹老板", "章鱼哥", "痞老板", "泡芙老师"}
my_set.clear()
print(my_set)

set()

取出集合之间的差集

集合1.difference(集合2)

取出集合1和集合2的差集，集合1有的而集合2没有的，得到一个新集合，但是集合1和集合2不变

my_set1 = {1, 2, 3, 'a', 'b', 'c'}
my_set2 = {1, 2, 3}
print(my_set1.difference(my_set2))
print(my_set1)
print(my_set2)

{'b', 'c', 'a'}
{1, 2, 3, 'c', 'b', 'a'}
{1, 2, 3}

消除集合之间的差集

集合1.difference_update(集合2)

对比集合1和集合2，在集合1内删除和集合2相同的元素，集合1被修改，集合2不变

my_set1 = {1, 2, 3, 'a', 'b', 'c'}
my_set2 = {1, 2, 3}
my_set1.difference_update(my_set2)
print(my_set1)
print(my_set2)

{'a', 'b', 'c'}
{1, 2, 3}

集合之间合并

集合1.union(集合2)

将集合1和集合2组合成新集合，集合1和集合2不变

my_set1 = {1, 2, 3, 'a', 'b', 'c'}
my_set2 = {1, 2, 3}
my_set3 = my_set1.union(my_set2)
print(my_set1)
print(my_set2)
print(my_set3)

{1, 2, 3, 'a', 'c', 'b'}
{1, 2, 3}
{1, 2, 3, 'a', 'c', 'b'}

集合元素数量

len(集合)

my_set = {"姗迪", "海绵宝宝", "派大星", "蟹老板", "章鱼哥", "痞老板", "泡芙老师", "姗迪", "海绵宝宝", "派大星", "蟹老板", "章鱼哥", "痞老板", "泡芙老师"}

print(len(my_set))

7

遍历集合

遍历集合不支持while，因为集合不支持下标索引，但可用for循环遍历

my_set = {"姗迪", "海绵宝宝", "派大星", "蟹老板", "章鱼哥", "痞老板", "泡芙老师", "姗迪", "海绵宝宝", "派大星", "蟹老板", "章鱼哥", "痞老板", "泡芙老师"}

for element in my_set:
    print(element)

痞老板
蟹老板
章鱼哥
姗迪
海绵宝宝
泡芙老师
派大星

集合总结

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

my_list = ["姗迪", "海绵宝宝", "派大星", "蟹老板", "章鱼哥", "痞老板", "泡芙老师", "姗迪", "海绵宝宝", "派大星", "蟹老板", "章鱼哥", "痞老板", "泡芙老师"]
my_set = set()
for element in my_list:
    my_set.add(element)

print(f"列表：{my_list}")
print(f"存入集合后结果：{my_set}")

列表：['姗迪', '海绵宝宝', '派大星', '蟹老板', '章鱼哥', '痞老板', '泡芙老师', '姗迪', '海绵宝宝', '派大星', '蟹老板', '章鱼哥', '痞老板', '泡芙老师']
存入集合后结果：{'蟹老板', '痞老板', '海绵宝宝', '姗迪', '派大星', '章鱼哥', '泡芙老师'}

8 数据容器：dict(字典、映射)

字典同样使用{}，不过存储的元素是一个个的：键值对

字典定义

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

字典同集合一样，不可以使用下标索引，但是字典可以通过key来取得对应的value

my_dict = {"海绵宝宝": 98, "派大星": 54, "章鱼哥": 100}
print(my_dict["海绵宝宝"])
print(my_dict["派大星"])
print(my_dict["章鱼哥"])

98
54
100

字典嵌套

字典的key和value可以是任意数据类型(key不可为字典)，可以嵌套

stu_score_dict = {
    "海绵宝宝": {
        "语文": 77,
        "数学": 66,
        "英语": 33
    },
    "派大星": {
        "语文": 88,
        "数学": 86,
        "英语": 55
    },
    "章鱼哥": {
        "语文": 99,
        "数学": 96,
        "英语": 66
    }}
print(f"海绵宝宝的语文成绩：{stu_score_dict['海绵宝宝']['语文']}")
print(f'派大星的各科成绩：{stu_score_dict["派大星"]}')

海绵宝宝的语文成绩：77
派大星的各科成绩：{'语文': 88, '数学': 86, '英语': 55}

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

新增/更新元素

字典[key] = value

字典被修改，value值改变，key存在则更新value，key不存在则增加value

stu_score_dict = {
    "海绵宝宝": {
        "语文": 77,
        "数学": 66,
        "英语": 33
    },
    "派大星": {
        "语文": 88,
        "数学": 86,
        "英语": 55
    },
    "章鱼哥": {
        "语文": 99,
        "数学": 96,
        "英语": 66
    }}

stu_score_dict['海绵宝宝']['语文'] = 90
stu_score_dict['海绵宝宝']['体育'] = 95
print(f"海绵宝宝的各科成绩：{stu_score_dict['海绵宝宝']}")

海绵宝宝的各科成绩：{'语文': 90, '数学': 66, '英语': 33, '体育': 95}

删除元素

字典.pop(key)

获得指定key的value，同时字典被修改，指定key的数据被删除

stu_score_dict = {
    "海绵宝宝": {
        "语文": 77,
        "数学": 66,
        "英语": 33
    },
    "派大星": {
        "语文": 88,
        "数学": 86,
        "英语": 55
    },
    "章鱼哥": {
        "语文": 99,
        "数学": 96,
        "英语": 66
    }}

stu_score_dict.pop("章鱼哥")
print(f"学生的各科成绩：{stu_score_dict}")

学生的各科成绩：{'海绵宝宝': {'语文': 77, '数学': 66, '英语': 33}, '派大星': {'语文': 88, '数学': 86, '英语': 55}}

清空字典

字典.clear()

字典被修改，元素被清空

stu_score_dict = {
    "海绵宝宝": {
        "语文": 77,
        "数学": 66,
        "英语": 33
    },
    "派大星": {
        "语文": 88,
        "数学": 86,
        "英语": 55
    },
    "章鱼哥": {
        "语文": 99,
        "数学": 96,
        "英语": 66
    }}

stu_score_dict.clear()
print(f"学生的各科成绩：{stu_score_dict}")

学生的各科成绩：{}

获取全部key

字典.keys()

得到字典中的全部key

stu_score_dict = {
    "海绵宝宝": {
        "语文": 77,
        "数学": 66,
        "英语": 33
    },
    "派大星": {
        "语文": 88,
        "数学": 86,
        "英语": 55
    },
    "章鱼哥": {
        "语文": 99,
        "数学": 96,
        "英语": 66
    }}

print(f"学生姓名：{stu_score_dict.keys()}")

学生姓名：dict_keys(['海绵宝宝', '派大星', '章鱼哥'])

遍历字典

方式一

取出所有key的基础上用for循环遍历

stu_score_dict = {
    "海绵宝宝": {
        "语文": 77,
        "数学": 66,
        "英语": 33
    },
    "派大星": {
        "语文": 88,
        "数学": 86,
        "英语": 55
    },
    "章鱼哥": {
        "语文": 99,
        "数学": 96,
        "英语": 66
    }}
keys = stu_score_dict.keys()
for key in keys:
    print(f"学生姓名:{key}")
    print(f"学生各科成绩:{stu_score_dict[key]}")

学生姓名:海绵宝宝
学生各科成绩:{'语文': 77, '数学': 66, '英语': 33}
学生姓名:派大星
学生各科成绩:{'语文': 88, '数学': 86, '英语': 55}
学生姓名:章鱼哥
学生各科成绩:{'语文': 99, '数学': 96, '英语': 66}

方式二

直接对字典for循环，每一次循环都是直接得到key

stu_score_dict = {
    "海绵宝宝": {
        "语文": 77,
        "数学": 66,
        "英语": 33
    },
    "派大星": {
        "语文": 88,
        "数学": 86,
        "英语": 55
    },
    "章鱼哥": {
        "语文": 99,
        "数学": 96,
        "英语": 66
    }}

for key in stu_score_dict:
    print(f"学生姓名:{key}")
    print(f"学生各科成绩:{stu_score_dict[key]}")

学生姓名:海绵宝宝
学生各科成绩:{'语文': 77, '数学': 66, '英语': 33}
学生姓名:派大星
学生各科成绩:{'语文': 88, '数学': 86, '英语': 55}
学生姓名:章鱼哥
学生各科成绩:{'语文': 99, '数学': 96, '英语': 66}

不支持下标索引，因此不支持while循环

字典元素数量

len(字典)

stu_score_dict = {
    "海绵宝宝": {
        "语文": 77,
        "数学": 66,
        "英语": 33
    },
    "派大星": {
        "语文": 88,
        "数学": 86,
        "英语": 55
    },
    "章鱼哥": {
        "语文": 99,
        "数学": 96,
        "英语": 66
    }}

print(len(stu_score_dict))

3

操作总结

字典特点：

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

company = {
    "王力宏": {
        "部门": "科技部",
        "工资": 3000,
        "级别": 1
    },
    "周杰伦": {
        "部门": "市场部",
        "工资": 5000,
        "级别": 2
    },
    "林俊杰": {
        "部门": "市场部",
        "工资": 7000,
        "级别": 3
    },
    "张学友": {
        "部门": "科技部",
        "工资": 4000,
        "级别": 1
    },
    "刘德华": {
        "部门": "市场部",
        "工资": 6000,
        "级别": 2
    }
}
print(f'全体员工当前信息如下：\n{company}')

for employee in company:
    if company[employee]['级别'] == 1:
        company[employee]['级别'] += 1
        company[employee]['工资'] += 1000

print(f'全体员工级别为1的员工完成升职加薪操作，操作后：\n{company}')

全体员工当前信息如下：
{'王力宏': {'部门': '科技部', '工资': 3000, '级别': 1}, '周杰伦': {'部门': '市场部', '工资': 5000, '级别': 2}, '林俊杰': {'部门': '市场部', '工资': 7000, '级别': 3}, '张学友': {'部门': '科技部', '工资': 4000, '级别': 1}, '刘德华': {'部门': '市场部', '工资': 6000, '级别': 2}}
全体员工级别为1的员工完成升职加薪操作，操作后：
{'王力宏': {'部门': '科技部', '工资': 4000, '级别': 2}, '周杰伦': {'部门': '市场部', '工资': 5000, '级别': 2}, '林俊杰': {'部门': '市场部', '工资': 7000, '级别': 3}, '张学友': {'部门': '科技部', '工资': 5000, '级别': 2}, '刘德华': {'部门': '市场部', '工资': 6000, '级别': 2}}

9 数据容器总结对比

数据容器分类

是否支持下标索引：

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

是否支持重复元素：

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

是否可以修改：

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

各数据容器应用场景：

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

10 数据容器的通用操作

遍历上：

• 5类数据容器都支持for循环遍历
• 列表、元组、字符串支持while循环，集合、字典不支持(无法下标索引)

尽管遍历形式各不相同，但都支持遍历操作

len(容器)：统计容器的元素个数
max(容器)：统计容器的最大元素
min(容器)：统计容器的最小元素
list(容器)：将给定容器转换为列表
str(容器)：将给定容器转换为字符串
tutple(容器)：将给定容器转换为元组
set(容器)：将给定容器转换为集合
sorted(容器, [reverse = True])：将给定容器进行排序，当需要设置反向排序时，加上中括号的内容

company = {
    "王力宏": {
        "部门": "科技部",
        "工资": 3000,
        "级别": 1
    },
    "周杰伦": {
        "部门": "市场部",
        "工资": 5000,
        "级别": 2
    },
    "林俊杰": {
        "部门": "市场部",
        "工资": 7000,
        "级别": 3
    },
    "张学友": {
        "部门": "科技部",
        "工资": 4000,
        "级别": 1
    },
    "刘德华": {
        "部门": "市场部",
        "工资": 6000,
        "级别": 2
    }
}

print(list(company))
# 字典转换成列表，只保留key部分，抛弃value
['王力宏', '周杰伦', '林俊杰', '张学友', '刘德华']

print(str(company))
# 字典转换成字符串，形式不变，默认输出的双引号不显示
{'王力宏': {'部门': '科技部', '工资': 3000, '级别': 1}, '周杰伦': {'部门': '市场部', '工资': 5000, '级别': 2}, '林俊杰': {'部门': '市场部', '工资': 7000, '级别': 3}, '张学友': {'部门': '科技部', '工资': 4000, '级别': 1}, '刘德华': {'部门': '市场部', '工资': 6000, '级别': 2}}

print(sorted(company))
# 从小到大排列
['刘德华', '周杰伦', '张学友', '林俊杰', '王力宏']

print(sorted(company, reverse=True))
# 从大到小排列
['王力宏', '林俊杰', '张学友', '周杰伦', '刘德华']

其他类型没有办法转换成字典，因为没有键值对

字符串大小比较

ASCII码表

大小写英文单词、数字、特殊符号（!、\、|、@、#、空格）都有其对应的ASCII码表，字符串的比较就是基于码值大小进行比较

字符串按位比较，只要有一位大，后面就无需比较了

总结