Python-Python数据容器：数据容器:list、列表的定义、下标索引（下标（索引）反向、嵌套的下标（索引））、常用操作（查询方法、修改方法）、遍历、数据容器（tuple(元组)、str(字符串

版本说明

当前版本号[20230718]。

版本	修改说明
20230718	初版

知识总览图

目录

Python数据容器

数据容器入门

思考一个问题：如果我想要在程序中，记录5名学生的信息，如姓名。

如何做呢？

学习数据容器，就是为了批量存储或批量使用多份数据

Python中的数据容器：

一种可以容纳多份数据的数据类型，容纳的每一份数据称之为1个元素

每一个元素，可以是任意类型的数据，如字符串、数字、布尔等。

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

•是否支持重复元素

•是否可以修改

•是否有序，等

分为5类，分别是：

列表（list）、元组（tuple）、字符串（str）、集合（set）、字典（dict）它们各有特点，但都满足可容纳多个元素的特性。

数据容器：list(列表)

列表的定义

思考：有一个人的姓名(TOM)怎么在程序中存储？

答：字符串变量

思考：如果一个班级100位学生，每个人的姓名都要存储，应该如何书写程序？声明100个变量吗？

答：No，我们使用列表就可以了， 列表一次可以存储多个数据

列表（list）类型，是数据容器的一类，我们来详细学习它。

基本语法：

列表内的每一个数据，称之为元素

• 以 [ ] 作为标识
• 列表内每一个元素之间用, 逗号隔开

案例演示：使用[]的方式定义列表

#在Python中，单引号和双引号都可以用来表示字符串。
name = ['张小三', '王小二', '龙小一']
print(name)
print(type(name))

嵌套列表的定义

元素的数据类型没有任何限制，甚至元素也可以是列表，这样就定义了嵌套列表

列表的下标索引

如何从列表中取出特定位置的数据呢？

我们可以使用：下标索引

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

我们只需要按照下标索引，即可取得对应位置的元素。

列表的下标（索引） - 反向

或者，可以反向索引，也就是从后向前：从-1开始，依次递减（-1、-2、-3…）

如图，从后向前，下标索引为：-1、-2、-3，依次递减。

嵌套列表的下标（索引）

如果列表是嵌套的列表，同样支持下标索引

如图，下标就有2个层级了。

注：

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

列表的常用操作

列表的常用操作（方法）

列表除了可以：

•定义

•使用下标索引获取值

以外，列表也提供了一系列功能：

•插入元素

•删除元素

•清空列表

•修改元素

•统计元素个数

等等功能，这些功能我们都称之为：列表的方法

列表的查询功能（方法）

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

在Python中，如果将函数定义为class（类）的成员，那么函数会称之为：方法

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

关于类和方法的定义，在面向对象章节我们学习，目前我们知道如何使用方法即可。

•查找某元素的下标

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

语法：

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

列表的修改功能（方法）

•修改特定位置（索引）的元素值

语法：

列表[下标] = 值

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

•插入元素

语法：

列表.insert(下标, 元素)

在指定的下标位置，插入指定的元素

•追加元素

语法：

列表.append(元素)

将指定元素，追加到列表的尾部

•追加元素方式2

语法：

列表.extend(其它数据容器)

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

•删除元素

语法1：

del 列表[下标] 【仅仅能够完成删除】

列表.pop(下标) 【不仅能把元素删掉，还能把该元素作为返回值得到】

•删除某元素在列表中的第一个匹配项

语法：列表.remove(元素)

在列表里相当于从前到后去搜索，把第一个符合的元素删掉（而且只能删掉一个）

•清空列表内容

语法：列表.clear()

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

语法：列表.count(元素)

•统计列表内，有多少元素

语法：len(列表)

可以得到一个int数字，表示列表内的元素数量

列表的方法 - 总览

列表的方法 - 说明

​ 学习编程，不仅仅是Python语言本身，以后根据方向，会学习更多的框架技术。除了经常用的，大多数是记忆不下来的。

​ 我们要做的是，有一个模糊印象，知晓有这样的用法即可。需要的时候，随时查阅资料即可。

列表的特点

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

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

练习案例:常用功能练习

有一个列表，内容是：[21, 25, 21, 23, 22, 20]，记录的是一批学生的年龄

请通过列表的功能（方法），对其进行：

1. 定义这个列表，并用变量接收它
2. 追加一个数字31，到列表的尾部
3. 追加一个新列表[29, 33, 30]，到列表的尾部
4. 取出第一个元素（应是：21）
5. 取出最后一个元素（应是：30）
6. 查找元素31，在列表中的下标位置

示例代码：

age = [21, 25, 21, 23, 22, 20]
age.append(31)
age.extend([29, 33, 30])
k = age[0]
j = age[-1]
o = age.index(31)

print(f"取出的元素k是：{k}")
print(f"取出的元素j是：{j}")
print(f"31的下标是：{o}")
print(f"元素age含：{age}")

list（列表）的遍历

列表的遍历 - while循环

既然数据容器可以存储多个元素，那么，就会有需求从容器内依次取出元素进行操作。

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

如何遍历列表的元素呢？

• 可以使用前面学过的while循环

如何在循环中取出列表的元素呢？

• 使用列表[下标]的方式取出

循环条件如何控制？

• 定义一个变量表示下标，从0开始

循环条件为 ：下标值 < 列表的元素数量

如：

age = [3, 5, 7, 9, 11]
i = 0
while i <len(age):
    k = age[i]
    print(f"age中的元素有：{k}")

    i += 1

列表的遍历 - for循环

除了while循环外，Python中还有另外一种循环形式：for循环。

对比while，for循环更加适合对列表等数据容器进行遍历。

** 每一次循环将列表中的元素取出，赋值到变量i，供操作**

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

while循环和for循环的对比

while循环和for循环，都是循环语句，但细节不同：

•在循环控制上：

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

•在无限循环上：

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

•在使用场景上：

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

练习案例：取出列表内的偶数

定义一个列表，内容是：[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

•遍历列表，取出列表内的偶数，并存入一个新的列表对象中

•使用while循环和for循环各操作一次

提示：

•通过if判断来确认偶数

•通过列表的append方法，来增加元素

示例代码：

nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
evens = []
i = 0
while i < len(nums):
    num = nums[i]
    if num % 2 == 0:
        evens.append(num)
    i += 1
print(f"经过while循环，从[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]取出偶数：{evens}")
"""
	这段代码的作用是，从列表 nums 中取出所有的偶数，保存到另一个列表 evens 中，并输出新列表的内容。
	首先，我们定义了一个空列表 evens 用来存放偶数。然后定义一个变量 i 作为计数器，初始值为 0。
	在 while 循环中，通过判断 i 是否小于原始列表的长度，来遍历原始列表 nums 的每一个元素。对于列表中的每个元素赋值给变量 num。
	在 if 语句里，我们检查 num 是否为偶数，如果是，就将它添加到新的列表 evens 中。
	最后，计数器 i 加 1, 循环继续，处理下一个元素，直到遍历完原始列表。最后打印新列表 evens 中的偶数元素，完成操作。
"""
en = []
o = 0
for o in nums:
    if o % 2 == 0:
        en.append(o)

print(f"经过for循环，从[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]取出偶数：{en}")
"""
	这段代码的作用是从列表 nums 中取出所有偶数，存储到一个新的列表 en 中，并输出新列表中的元素。
	首先，我们定义了一个空列表 en 用来存放处理后的偶数。然后使用 for 循环遍历原始列表中的每个元素。
	在循环之间，为了方便和规范一般会多加一个变量名作为计数器来表示当前循环次数或装表索引，此处可以将 o = 0 删除。
	对于列表中的每个元素 o，通过判断 o 是否为偶数，如果是，就将它添加到新的列表 en 中。
	最后， 使用 print 打印出新列表 en 中的元素内容，完成操作。
"""

结果显示：

数据容器：tuple(元组)

思考：列表是可以修改的。如果想要传递的信息，不被篡改，列表就不合适了。

元组同列表一样，都是可以封装多个、不同类型的元素在内。

但最大的不同点在于：

• 元组一旦定义完成，就不可修改

所以，当我们需要在程序内封装数据，又不希望封装的数据被篡改，那么元组就非常合适了

定义元组

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

元组也支持嵌套：

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

元组的相关操作

注：

元组由于不可修改的特性，所以其操作方法非常少。

元组的相关操作 - 注意事项

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

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

不可以替换list为其它list或其它类型（可以修改内部list的内部元素）

元组的遍历

同列表一样，元组也可以被遍历。可以使用while循环和for循环遍历它。

元组的特点

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

•可以容纳多个数据

•可以容纳不同类型的数据（混装）

•数据是有序存储的（下标索引）

•允许重复数据存在

•不可以修改（增加或删除元素等）

•支持for循环

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

多数特性和list一致，不同点在于不可修改的特性。

练习案例:元组的基本操作

定义一个元组，内容是：（‘马冬梅’, 18, [‘football’, ‘music’]），记录的是一个学生的信息（姓名、年龄、爱好）

请通过元组的功能（方法），对其进行

1.查询其年龄所在的下标位置

2.查询学生的姓名

3.删除学生爱好中的football

4.增加爱好：coding到爱好list内、

示例代码：

student = ('马冬梅', 18, ['football', 'music'])
num1 = student.index(18)
print(f"年龄所在的下标位置为：{num1}")
num2 = student[0]
print(f"学生的姓名为：{num2}")
del student[2][0]
print(f"目前学生的信息还剩：{student}")
student[2].append('football')
print(f"目前学生的信息为：{student}")

数据容器：str(字符串)

再识字符串

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

但不可否认的是，字符串同样也是数据容器的一员。

**字符串是字符的容器，一个字符串可以存放任意数量的字符。支持下标索引等特性 **

如，字符串：“itheima”

字符串的下标（索引）

和其它容器如：列表、元组一样，字符串也可以通过下标进行访问

• 从前向后，下标从0开始
• 从后向前，下标从-1开始

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

所以：

•修改指定下标的字符 （如：字符串[0] = “a”）

•移除特定下标的字符 （如：del 字符串[0]、字符串.remove()、字符串.pop()等）

•追加字符等 （如：字符串.append()）

均无法完成。如果必须要做，只能得到一个新的字符串，旧的字符串是无法修改

字符串的常用操作

• 查找特定字符串的下标索引值

  语法：

字符串.index(字符串)

如果想通过下标位置，反过来看对于原语句的部分，可以使用以下语法【不使用index】：

date = "Hello world and hello  everyone!"
num = date[1:10]
print(num)

• 字符串的替换

  语法：

字符串.replace(字符串1，字符串2）

功能：将字符串内的全部：字符串1，替换为字符串2

注意：不是修改字符串本身，而是得到了一个新字符串哦

可以看到，字符串name本身并没有发生变化，而是得到了一个新字符串对象。

• 字符串的分割

  语法：

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

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

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

​ 可以看到，字符串按照给定的 <空格>进行了分割，变成多个子字符串，并存入一个列表对象中。

• 字符串的规整操作（去前后空格）

语法：

字符串.strip()

• 字符串的规整操作（去前后指定字符串）

语法：

字符串.strip(字符串)

注意：

传入的是“12” 其实就是：”1”和”2”都会移除，是按照单个字符。

• 统计字符串中某字符串的出现次数

语法：

字符串.count(字符串)

注：此时是区分大小写的，因为是按字符来的！

• 统计字符串的长度

语法：

len(字符串)

可以看出：

•数字（1、2、3…）

•字母（abcd、ABCD等）

•符号（空格、!、@、#、$等）

•中文

均算作1个字符

所以上述代码，结果20

字符串常用操作汇总

字符串的遍历

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

字符串的特点

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

•只可以存储字符串

•长度任意（取决于内存大小）

•支持下标索引

•允许重复字符串存在

•不可以修改（增加或删除元素等）

•支持for循环

基本和列表、元组相同

不同与列表和元组的在于：字符串容器可以容纳的类型是单一的，只能是字符串类型。

不同于列表，相同于元组的在于：字符串不可修改

练习案例：分割字符串

给定一个字符串：“itheima itcast boxuegu”

• 统计字符串内有多少个"it"字符
• 将字符串内的空格，全部替换为字符：“|”
• 并按照"|"进行字符串分割，得到列表

提示：

count、replace、split

示例代码：

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

数据容器的切片

序列

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

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

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

序列的常用操作 - 切片

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

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

语法：

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

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

• 起始下标表示从何处开始，可以留空，留空视作从头开始

• 结束下标（不含）表示何处结束，可以留空，留空视作截取到结尾

• 步长表示，依次取元素的间隔

• 步长1表示，一个个取元素

• 步长2表示，每次跳过1个元素取

• 步长N表示，每次跳过N-1个元素取

• 步长为负数表示，反向取（注意，起始下标和结束下标也要反向标记）

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

序列如何做切片

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

• 起始可以省略，省略从头开始
• 结束可以省略，省略到尾结束
• 步长可以省略，省略步长为1（可以为负数，表示倒序执行）

序列的切片演示

num_list = [1, 2, 3, 4, 5]
new_list = num_list[1:4]#下标1开始，下标4（不含）结束，默认步长为1
print(new_list)

num_tuple = (2, 4, 6, 8, 10)
new_tuple = num_tuple[1:4:1]#下标1开始，下标4（不含）结束，步长为2
print(new_tuple)

ss_list = [1, 3, 5, 7, 9]
newss_list = ss_list[::2]#从头开始，到最后结束，步长为2
print(newss_list)

ss_tuple = (5, 7, 9, 11, 13)
newss_tuple = ss_tuple[:4:2]#从头开始，到下标4（不含）结束，步长为2
print(newss_tuple)

包括倒序也是可以的

num_list = [1, 2, 3, 4, 5]
new_list = num_list[1::-2]
print(new_list)
“”“
输出结果为 [2]，这是因为 num_list[1::-2] 这个切片操作：
	起始下标为 1，所以选取了列表中第二个元素；
	步长为 -2，表示从起始下标开始向前每隔两个元素选取一个（步长方向要看是否反转，-2 表示右往左的反向选择）；
	最终得到的序列只有 2 这一个元素符合条件，所以 new_list 中就只有 2 了。
“”“

num_tuple = (2, 4, 6, 8, 10)
new_tuple = num_tuple[:1:-2]
print(new_tuple)
“”“
输出结果为 (10, 6)，这是因为 num_tuple[:1:-2] 这个切片操作：
	结束下标为 -2（不包括 -2），表示从最后一个元素开始向前每隔两个元素选取一个；
	起始下标没有指定，所以从第一个元素开始选取；
	最终得到的序列中只有 10 和 6 两个元素符合条件，所以 new_tuple 就是它们构成的元组 (10, 6)。
“”“

num_str = "12345"
new_str = num_str[::-1]#从头（最后）开始，到尾结束，步长-1（倒序）
print(new_str)

可以看到，这个操作对列表、元组、字符串是通用的

同时非常灵活，根据需求，起始位置，结束位置，步长（正反序）都是可以自行控制的

练习案例：序列的切片实践

有字符串：“难更人路行，难路行”

•请使用学过的任何方式，得到"行路人"

可用方式参考：

• 倒序字符串，切片取出或切片取出，然后倒序
• split分隔"，" replace替换"来"为空，倒序字符串

num_str = "难更人路行，难路行"
new_str = num_str[::-1]
print(f"将其倒序完显示：{new_str}")

newss_str = new_str[4:7]
print(f"方式1的结果是：{newss_str}")

newkk_str = num_str[::-1][4:7]
print(f"方式2的结果是：{newkk_str}")

newoo_str = num_str.split("，")[0].replace("难更", "")[::-1]
print(f"方式3的结果是：{newoo_str}")

数据容器：set(集合)

为什么使用集合

我们目前接触到了列表、元组、字符串三个数据容器了。基本满足大多数的使用场景。

为何又需要学习新的集合类型呢？

通过特性来分析：

• 列表可修改、支持重复元素且有序
• 元组、字符串不可修改、支持重复元素且有序

有没有看出一些局限？

局限就在于：它们都支持重复元素。

如果场景需要对内容做去重处理，列表、元组、字符串就不方便了。

而集合，最主要的特点就是：不支持元素的重复（自带去重功能）、并且内容无序

集合的定义

基本语法：

和列表、元组、字符串等定义基本相同：

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

示例代码：

name = {"鸣人", "卡莉熙", "志田未来"}
names = {"鸣人", "卡莉熙", "志田未来", "鸣人", "卡莉熙", "志田未来","鸣人", "卡莉熙", "志田未来"}
print(name)
print(names)

结果中可见：去重且无序

因为要对元素做去重处理，所以无法保证顺序和创建的时候一致

集合的常用操作 - 修改

首先，因为集合是无序的，所以集合不支持：下标索引访问

但是集合和列表一样，是允许修改的，所以我们来看看集合的修改方法。

•添加新元素

语法：

集合.add(元素)

将指定元素，添加到集合内

结果：集合本身被修改，添加了新元素

•移除元素

语法：

集合.remove(元素)

将指定元素，从集合内移除

结果：集合本身被修改，移除了元素

•从集合中随机取出元素

语法：

集合.pop()

功能，从集合中随机取出一个元素

结果：会得到一个元素的结果。同时集合本身被修改，元素被移除

•清空集合

语法：

集合.clear()

功能，清空集合

结果：集合本身被清空

以上示例代码：

name = {"鸣人", "卡莉熙", "志田未来"}
print(f"name内原元素为:{name}")

name.add("太宰治")
name.add("鸣人")
print(f"添加了新元素后，name内的元素为：{name}")

name.remove("卡莉熙")
print(f"移除了旧元素后，name内的元素为：{name}")

name_pop = name.pop()
print(f"随机取出了name中的 {name_pop} 元素")

name.clear()
print(f"清除了所有元素后，name内的元素为：{name}")

•取出2个集合的差集

语法：

集合1.difference(集合2)

功能：取出集合1和集合2的差集（集合1有而集合2没有的）

结果：得到一个新集合，集合1和集合2不变

•消除2个集合的差集

语法：

集合1.difference_update(集合2)

功能：对比集合1和集合2，在集合1内，删除和集合2相同的元素。

结果：集合1被修改，集合2不变

•2个集合合并

语法：

集合1.union(集合2)

功能：将集合1和集合2组合成新集合

结果：得到新集合，集合1和集合2不变

集合的常用操作 - 集合长度

•查看集合的元素数量

语法：

len(集合)

功能：统计集合内有多少元素

结果：得到一个整数结果

集合的常用操作 - for循环遍历

集合同样支持使用for循环遍历

要注意：集合不支持下标索引，所以也就不支持使用while循环。

以上示例代码：

name01 = {"鸣人", "卡莉熙", "志田未来"}
name02 = {"琪琪", "凯路斯·利马尽", "志田未来"}
name03 = name02.difference(name01)
print(f"两个列表对象之间不同的元素为：{name03}")

name02.difference_update(name01)
print(f"去除完两个对象之间的相同的元素后，name01还剩余元素为：{name01}")
print(f"去除完两个对象之间的相同的元素后，name02还剩余元素为：{name02}")

name04 = name02.union(name01)
print(f"合并完两个对象之间的元素后，name04里的元素为：{name04}")

print(f"name04里的元素长度为：{len(name04)}")

name05 = {"大雄", "小雄"}
for i in name05:
    print(i)

集合常用功能总结

集合的特点

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

•可以容纳多个数据

•可以容纳不同类型的数据（混装）

•数据是无序存储的（不支持下标索引）

•不允许重复数据存在

•可以修改（增加或删除元素等）

•支持for循环

练习案例：信息去重

有如下列表对象：

name = [“三藏”, “Harry Potter”, “柿子”, “远坂凛”, “赤井秀一”, “远坂凛”, “加藤惠”, “Harry Potter”, “Tony Stark”, “Harry Potter”, “Sheldon Cooper”]

请：

•定义一个空集合

•通过for循环遍历列表

•在for循环中将列表的元素添加至集合

•最终得到元素去重后的集合对象，并打印输出

name = ["三藏", "Harry Potter", "柿子", "远坂凛", "赤井秀一", "远坂凛", "加藤惠", "Harry Potter", "Tony Stark", "Harry Potter", "Sheldon Cooper"]
new_name = set()
for i in name:
   new_name.add(i)

print(f"原先的元素为：{name}")
print(f"变成集合后，集合内的元素为：{new_name}")

输出结果为：
原先的元素为：['三藏', 'Harry Potter', '柿子', '远坂凛', '赤井秀一', '远坂凛', '加藤惠', 'Harry Potter', 'Tony Stark', 'Harry Potter', 'Sheldon Cooper']
变成集合后，集合内的元素为：{'三藏', '柿子', '远坂凛', 'Tony Stark', '加藤惠', 'Harry Potter', '赤井秀一', 'Sheldon Cooper'}

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

字典的定义

Python中字典和生活中字典十分相像：

老师有一份名单，记录了学生的姓名和考试总成绩。

现在需要将其通过Python录入至程序中，并可以通过学生姓名检索学生的成绩。

使用字典最为合适：

可以通过Key（学生姓名），取到对应的Value（考试成绩）

所以，为什么使用字典？

因为可以使用字典，实现用key取出Value的操作

字典的定义，同样使用{}，不过存储的元素是一个个的：键值对，如下语法：

•使用{}存储原始，每一个元素是一个键值对

•每一个键值对包含Key和Value（用冒号分隔）

•键值对之间使用逗号分隔

•Key和Value可以是任意类型的数据（key不可为字典）

•Key不可重复，重复会对原有数据覆盖

前文中记录学生成绩的需求，可以如下记录：

name = {"韦冬梅": 99, "米老鼠": 88, "皮卡丘": 77}
print(f"name里面的元素有{name},类型是{type(name)}")

字典数据的获取

字典同集合一样，不可以使用下标索引

但是字典可以通过Key值来取得对应的Value

name = {"韦冬梅": 99, "米老鼠": 88, "皮卡丘": 77}
print(name["韦冬梅"])
print(name["米老鼠"])
print(name["皮卡丘"])

字典的嵌套

字典的Key和Value可以是任意数据类型（Key不可为字典）

那么，就表明，字典是可以嵌套的

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

姓名	语文成绩	数学成绩	英语成绩
韦冬梅	99	77	45
米老鼠	88	99	54
皮卡丘	77	88	69

代码：

name = {"韦冬梅": {"语文": 99, "数学": 77, "英语": 45}, "米老鼠": {"语文": 88, "数学": 99, "英语": 54}, "皮卡丘": {"语文": 77, "数学": 88, "英语": 69}}

优化一下可读性，可以写成：

name = {
   "韦冬梅": {"语文": 99, "数学": 77, "英语": 45},
   "米老鼠": {"语文": 88, "数学": 99, "英语": 54},
   "皮卡丘": {"语文": 77, "数学": 88, "英语": 69}
}
print(name)

嵌套字典的内容获取

嵌套字典的内容获取，如下所示：

name = {
   "韦冬梅": {"语文": 99, "数学": 77, "英语": 45},
   "米老鼠": {"语文": 88, "数学": 99, "英语": 54},
   "皮卡丘": {"语文": 77, "数学": 88, "英语": 69}
}
print(name["韦冬梅"])
print(name["米老鼠"]["数学"])
print(name["皮卡丘"]["英语"])

字典的注意事项

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

字典的常用操作

•新增元素

语法：

字典[Key] = Value

结果：字典被修改，新增了元素

•更新元素

语法：

字典[Key] = Value

结果：字典被修改，元素被更新

注意：字典Key不可以重复，所以对已存在的Key执行上述操作，就是更新Value值

•删除元素

语法：

字典.pop(Key)

结果：获得指定Key的Value，同时字典被修改，指定Key的数据被删除

•清空字典

语法：

字典.clear()

结果：字典被修改，元素被清空

•获取全部的key

语法：

字典.keys()

结果：得到字典中的全部Key

•遍历字典

语法：

for key in 字典.keys()

注意：字典不支持下标索引，所以同样不可以用while循环遍历

•计算字典内的全部元素（键值对）数量

语法：

len(字典)

结果：得到一个整数，表示字典内元素（键值对）的数量

字典的常用操作总结

字典的特点

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

•可以容纳多个数据

•可以容纳不同类型的数据

•每一份数据是KeyValue键值对

•可以通过Key获取到Value，Key不可重复（重复会覆盖）

•不支持下标索引

•可以修改（增加或删除更新元素等）

•支持for循环，不支持while循环

练习案例：升职加薪

有如下员工信息，请使用字典完成数据的记录。

并通过for循环，对所有级别为1级的员工，级别上升1级，薪水增加1000元

示例代码：

name = {
   "韦冬梅": {"部门": "科技部", "工资": 3000, "级别": 1},
   "米老鼠": {"部门": "市场部", "工资": 5000, "级别": 2},
   "皮卡丘": {"部门": "市场部", "工资": 7000, "级别": 3},
   "皮可熊": {"部门": "科技部", "工资": 4000, "级别": 1},
   "波赛冬": {"部门": "市场部", "工资": 6000, "级别": 2},
}

for i in name:
   if name[i]["级别"] == 1:
      name[i]["级别"] += 1
      name[i]["工资"] += 1000

print(f"{name}")

输出结果：{'韦冬梅': {'部门': '科技部', '工资': 4000, '级别': 2}, '米老鼠': {'部门': '市场部', '工资': 5000, '级别': 2}, '皮卡丘': {'部门': '市场部', '工资': 7000, '级别': 3}, '皮可熊': {'部门': '科技部', '工资': 5000, '级别': 2}, '波赛冬': {'部门': '市场部', '工资': 6000, '级别': 2}}

扩展：数据容器对比总结

数据容器分类

数据容器可以从以下视角进行简单的分类：

•是否支持下标索引

•支持：列表、元组、字符串 - 序列类型

•不支持：集合、字典 - 非序列类型

•是否支持重复元素：

•支持：列表、元组、字符串 - 序列类型

•不支持：集合、字典 - 非序列类型

•是否可以修改

•支持：列表、集合、字典

不支持：元组、字符串

数据容器特点对比

数据容器的通用操作

数据容器的通用操作 - 遍历

数据容器尽管各自有各自的特点，但是它们也有通用的一些操作。

首先，在遍历上：

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

尽管遍历的形式各有不同，但是，它们都支持遍历操作。

数据容器的通用统计功能

除了遍历这个共性外，数据容器可以通用非常多的功能方法

容器的通用转换功能

除了下标索引这个共性外，还可以通用类型转换

容器通用排序功能

sorted(容器, [reverse=True])
#[reverse=True])意思是输出的排序为反序，记住[]不用加

将给定容器进行排序

注意，排序后都会得到列表（list）对象。

容器通用功能总览

扩展：字符串大小比较

ASCII码表

在程序中，字符串所用的所有字符如：

•大小写英文单词

•数字

•特殊符号(!、\、|、@、#、空格等）

都有其对应的ASCII码表值

每一个字符都能对应上一个：数字的码值

字符串进行比较就是基于数字的码值大小进行比较的。

字符串比较

字符串是按位比较，也就是一位位进行对比，只要有一位大，那么整体就大。

注意：

1. 字符串如何比较

   从头到尾，一位位进行比较，其中一位大，后面就无需比较了。

2. 单个字符之间如何确定大小？

   通过ASCII码表，确定字符对应的码值数字来确定大小

综合案例

1.幸运数字6：输入任意数字，如数字8，生成nums列表，元素值为1~8，从中选取幸运数字(能够被6整除)移动到新列表lucky，打印nums与lucky。

2.列表嵌套：有3个教室[[],[],[]]，8名讲师[‘A’,‘B’,‘C’,‘D’,‘E’,‘F’,‘G’,‘H’]，将8名讲师随机分配到3个教室中

第一题：

num = int(input("请输入任意数字："))
nums = [i for i in range(1, num+1)]
print(f"nums中的元素值有：{nums}")
lucky = []
for n in nums:
    if n % 6 == 0:
        lucky.append(n)
        
print(lucky)
”“”
	代码中，我们首先使用input()函数获取用户输入的数字，并用range()和list()函数创建了包含1到num的整数列表。然后，使用for循环遍历该列表，在每次迭代中判断当前元素是否能被6整除，如果是，则将其加入新列表lucky中。最后，使用print()函数打印输出nums和lucky两个列表。
	注意，在Python 3中，range()函数返回的是可迭代对象而不是列表，需要使用list()函数将其转换为列表类型，才能进行index访问等操作。
”“”

第二题：

classroom = [[], [], []]
teacher = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H']
import random
random.shuffle(teacher)
for i, teacher in enumerate(teacher):
    classroom[i % 3].append(teacher)

print("在教室1,分配的老师为：", classroom[0])
print("在教室2,分配的老师为：", classroom[1])
print("在教室3,分配的老师为：", classroom[2])
”“”
	代码中，我们首先创建了3个空列表作为教室，以及包含8个讲师名称的列表。使用random库中的shuffle()函数可以将讲师列表随机排序，然后使用for循环依次遍历每个讲师，并根据当前迭代次数计算其应该被分配到哪个教室中。具体来说，我们使用取模运算符(i%3)将索引值i映射到0、1、2三个值之一，以此来确定将该讲师添加到哪个教室中。最后，使用print()函数输出分配结果。
	需要注意的是，由于这里使用了shuffle()函数对原列表进行了修改，因此在实际开发过程中可能需要另外创建一个副本列表来进行分配操作，以避免影响原列表。
”“”