3. Python容器

先总结😁😁

数据容器分类：

• 是否支持下标索引
• 支持：列表、元组、字符串 – 序列类型
• 不支持：集合、字典 - -非序列类型
• 是否支持重复元素：
• 支持：列表、元组、字符串 - 序列类型
• 不支持：集合、字典 - 非序列类型
• 是否可以修改
• 支持：列表、集合、字典
• 不支持：元组、字符串

数据容器特点对比：

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

特点：基于各类数据容器的特点，它们的应用场景如下：

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

容器通用功能总览

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

# len元素个数
print(f"列表 元素个数有：{len(my_list)}")
print(f"元组 元素个数有：{len(my_tuple)}")
print(f"字符串元素个数有：{len(my_str)}")
print(f"集合 元素个数有：{len(my_set)}")
print(f"字典 元素个数有：{len(my_dict)}")

# max最大元素
print(f"列表 最大的元素是：{max(my_list)}")
print(f"元组 最大的元素是：{max(my_tuple)}")
print(f"字符串最大的元素是：{max(my_str)}")
print(f"集合 最大的元素是：{max(my_set)}")
print(f"字典 最大的元素是：{max(my_dict)}")
# min最小元素
print(f"列表 最小的元素是：{min(my_list)}")
print(f"元组 最小的元素是：{min(my_tuple)}")
print(f"字符串最小的元素是：{min(my_str)}")
print(f"集合 最小的元素是：{min(my_set)}")
print(f"字典 最小的元素是：{min(my_dict)}")
# 类型转换: 容器转列表
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)}")
# 类型转换: 容器转元组
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)}")
# 类型转换: 容器转字符串
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)}")
# 类型转换: 容器转集合
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)}")
# 进行容器的排序
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)}")

print(f"列表对象的反向排序结果：{sorted(my_list, reverse=True)}")
print(f"元组对象的反向排序结果：{sorted(my_tuple, reverse=True)}")
print(f"字符串对象反向的排序结果：{sorted(my_str, reverse=True)}")
print(f"集合对象的反向排序结果：{sorted(my_set, reverse=True)}")
print(f"字典对象的反向排序结果：{sorted(my_dict, reverse=True)}")   # 输出key，value丢失，顺序混乱

1. Python中的数据容器

一种可以容纳多份数据的数据类型，容纳的每一份数据称之为1个元素每一个元素，可以是任意类型的数据，如字符串、数字、布尔等。数据容器根据特点的不同，如：是否支持重复元素是否可以修改是否有序，等分为5类，分别是：

列表（list）、元组（tuple）、字符串（str）、集合（set）、字典（dict）

2. 函数和方法

函数是一个封装的代码单元，可以提供特定功能。在Python中，如果将函数定义为class（类）的成员，那么函数会称之为：方法。

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

函数的使用：num = add(1,2)

方法的使用：student = Student()

​ num = student.add(1,2)

# 函数
def add(x,y):
    return x + y

# 方法：在类中的函数
class Student:
    def add(self, x, y);
        return x +y

3. 列表（list）

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

• 以 [ ] 作为标识。

• 列表内每一个元素之间用逗号隔开。

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

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

基本语法

# 定义一个列表 list
my_list = ["itheima", 666, True]
print(my_list)
print(type(my_list))

# 定义一个嵌套的列表
my_list = [ [1, 2, 3], [4, 5, 6]]
print(my_list)
print(type(my_list))

列表的下标（索引）

正向索引：从前向后的方向，从0开始，依次递增

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

嵌套列表的下标（索引）

# 定义一个嵌套的列表
my_list = [ [1, 2, 3], [4, 5, 6]]
print(my_list)
print(type(my_list))

# 通过下标索引取出对应位置的数据
my_list = ["Tom", "Lily", "Rose"]
# 列表[下标索引], 从前向后从0开始，每次+1，从后向前从-1开始，每次-1
print(my_list[0])
print(my_list[1])
print(my_list[2])
# 错误示范；通过下标索引取数据，一定不要超出范围
# print(my_list[3])

# 通过下标索引取出数据（倒序取出）
print(my_list[-1])
print(my_list[-2])
print(my_list[-3])

# 取出嵌套列表的元素
my_list = [[1, 2, 3], [4, 5, 6]]
print(my_list[1][1])

列表的常用操作（方法）

查询：列表.index(元素)

修改：列表[下标] = 值

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

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

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

删除1：del 列表[下标]

删除2：列表.pop(下标)

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

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

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

统计列表内，有多少元素：len(列表) ，可以得到一个int数字，表示列表内的元素数量

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

列表的特点

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

"""
演示数据容器之：list列表的常用操作
"""
mylist = ["itcast", "itheima", "python"]
# 1.1 查找某元素在列表内的下标索引
index = mylist.index("itheima")
print(f"itheima在列表中的下标索引值是：{index}")
# 1.2如果被查找的元素不存在，会报错
# index = mylist.index("hello")
# print(f"hello在列表中的下标索引值是：{index}")

# 2. 修改特定下标索引的值
mylist[0] = "传智教育"
print(f"列表被修改元素值后，结果是：{mylist}")
# 3. 在指定下标位置插入新元素
mylist.insert(1, "best")
print(f"列表插入元素后，结果是：{mylist}")
# 4. 在列表的尾部追加```单个```新元素
mylist.append("黑马程序员")
print(f"列表在追加了元素后，结果是：{mylist}")
# 5. 在列表的尾部追加```一批```新元素
mylist2 = [1, 2, 3]
mylist.extend(mylist2)
print(f"列表在追加了一个新的列表后，结果是：{mylist}")
# 6. 删除指定下标索引的元素（2种方式）
mylist = ["itcast", "itheima", "python"]

# 6.1 方式1：del 列表[下标]
del mylist[2]
print(f"列表删除元素后结果是：{mylist}")
# 6.2 方式2：列表.pop(下标)
mylist = ["itcast", "itheima", "python"]
element = mylist.pop(2)
print(f"通过pop方法取出元素后列表内容：{mylist}, 取出的元素是：{element}")
# 7. 删除某元素在列表中的第一个匹配项
mylist = ["itcast", "itheima", "itcast", "itheima", "python"]
mylist.remove("itheima")
print(f"通过remove方法移除元素后，列表的结果是：{mylist}")

# 8. 清空列表
mylist.clear()
print(f"列表被清空了，结果是：{mylist}")
# 9. 统计列表内某元素的数量
mylist = ["itcast", "itheima", "itcast", "itheima", "python"]
count = mylist.count("itheima")
print(f"列表中itheima的数量是：{count}")

# 10. 统计列表中全部的元素数量
mylist = ["itcast", "itheima", "itcast", "itheima", "python"]
count = len(mylist)
print(f"列表的元素数量总共有：{count}个")

列表的遍历 - while循环和for循环

既然数据容器可以存储多个元素，那么，就会有需求从容器内依次取出元素进行操作。将容器内的元素依次取出进行处理的行为，称之为：遍历、迭代。

while循环和for循环的对比：

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

"""
演示使用while和for循环遍历列表
"""
def list_while_func():
    """
    使用while循环遍历列表的演示函数
    :return: None
    """
    my_list = [1,2,3,4,5]
    # 循环控制变量：通过下标索引来控制，默认0
    # 每一次循环将下标+1
    index = 0
    while index < len(my_list):
        # 通过index变量取出对应下标的元素
        element = my_list[index]
        print(f"列表元素有：{element}")
list_while_func()

def list_for_func():
    """
    使用for循环遍历列表的演示函数
    :return:
    """
    my_list = [1,2,3,4]
    # for 临时变量 in 数据容器：
    for element in my_list:
        print(f"列表元素有：{element}")
list_for_func()

4.元组（tuple)

元组同列表一样，都是可以封装多个、不同类型的元素在内。但最大的不同点在于：元组一旦定义完成，就不可修改。所以，当我们需要在程序内封装数据，又不希望封装的数据被篡改，那么元组就非常合适了。

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

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

# 定义单个元素的元素
t4 = ("hello", )
print(f"t4的类型是：{type(t4)}, t4的内容是：{t4}")

元组的嵌套：

t5 = ( (1, 2, 3), (4, 5, 6) )
print(f"t5的类型是：{type(t5)}, 内容是：{t5}")

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

| 编号 | 方法 | 作用 |
| ——– | ——— | ————————————————– |
| 1 | index() | 查找某个数据，如果数据存在返回对应的下标，否则报错 |
| 2 | count() | 统计某个数据在当前元组出现的次数 |
| 3 | len(元组) | 统计元组内的元素个数 |

注意事项：

• 不可以修改元组的内容，否则会直接报错
• 可以修改嵌套在元组内的list的内容（修改元素、增加、删除、反转等）
• 不可以替换list为其它list或其它类型

# 定义一个元组(嵌套一个list列表)
t9 = (1, 2, ["hgh", "hgh"])
print(f"t9的内容是：{t9}")
t9[2][0] = "6"
t9[2][1] = "6"
print(f"t9的内容是：{t9}")

元组的特点：

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

5. 字符串

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

字符串的下标（索引）

和其它容器如：列表、元组一样，字符串也可以通过下标进行访问：从前向后，下标从0开始；从后向前，下标从-1开始。

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

• 修改指定下标的字符 （如：字符串[0] = “a”）
• 移除特定下标的字符 （如：del 字符串[0]、字符串.remove()、字符串.pop()等）
• 追加字符等 （如：字符串.append()）

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

字符串的常用操作

• 查找特定字符串的下标索引值：字符串.index(字符串)
• 字符串的替换：字符串.replace(字符串1，字符串2）
• 功能：将字符串内的全部：字符串1，替换为字符串2
• 注意：字符串本身并没有被修改，而是得到了一个新字符串
• 字符串的分割：字符串.split(分隔符字符串）
• 功能：按照指定的分隔符字符串，将字符串划分为多个字符串，并存入列表对象中
• 字符串本身不变，而是得到了一个列表对象（字符串按照给定的 <空格>进行了分割，变成多个子字符串，并存入一个列表对象中）。
• 字符串的规整操作（去前后空格）：字符串.strip()
• 字符串的规整操作（去前后指定字符串：字符串.strip(字符串)
• 传入的是“12” 其实就是：”1”和”2”都会移除，是按照单个字符。
• 统计字符串中某字符串的出现次数：字符串.count(字符串)
• 统计字符串的长度：len(字符串)
• 注意：数字，字母，符号，中文，空格均算作1个字符

| 编号 | 操作 | 说明 |
| ——– | ———————————- | ———————————————————— |
| 1 | 字符串[下标] | 根据下标索引取出特定位置字符 |
| 2 | 字符串.index(字符串） | 查找给定字符的第一个匹配项的下标 |
| 3 | 字符串.replace(字符串1, 字符串2) | 将字符串内的全部字符串1，替换为字符串2不会修改原字符串，而是得到一个新的 |
| 4 | 字符串.split(字符串) | 按照给定字符串，对字符串进行分隔不会修改原字符串，而是得到一个新的列表 |
| 5 | 字符串.strip()字符串.strip(字符串) | 移除首尾的空格和换行符或指定字符串 |
| 6 | 字符串.count(字符串) | 统计字符串内某字符串的出现次数 |
| 7 | len(字符串) | 统计字符串的字符个数 |

"""
演示以数据容器的角色，学习字符串的相关操作
"""
my_str = "itheima and itcast"
# 通过下标索引取值
value = my_str[2]
value2 = my_str[-16]
print(f"从字符串{my_str}取下标为2的元素，。值是：{value},取下标为-16的元素。值是：{value2}")

# index方法
value = my_str.index("and")
print(f"在字符串{my_str}中查找and，其起始下标是：{value}")

# replace方法
new_my_str = my_str.replace("it", "程序")
print(f"将字符串{my_str}，进行替换后得到：{new_my_str}")

# split方法
my_str = "hello python itheima itcast"
my_str_list = my_str.split(" ")
print(f"将字符串{my_str}进行split切分后得到：{my_str_list}, 类型是：{type(my_str_list)}")

# strip方法
my_str = "  itheima and itcast  "
new_my_str = my_str.strip() # 不传入参数，去除首尾空格
print(f"字符串{my_str}被strip后，结果：{new_my_str}")

my_str = "12itheima and itcast21"
new_my_str = my_str.strip("12")
print(f"字符串{my_str}被strip('12')后，结果：{new_my_str}")

# 统计字符串中某字符串的出现次数, count
my_str = "itheima and itcast"
count = my_str.count("it")
print(f"字符串{my_str}中it出现的次数是：{count}")
# 统计字符串的长度, len()
num = len(my_str)
print(f"字符串{my_str}的长度是：{num}")

字符串的特点：

• 只可以存储字符串

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

• 支持下标索引

• 允许重复字符串存在

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

• 支持for循环

字符串基本和列表、元组相同

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

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

6. 序列

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

序列的常用操作 - 切片

切片：从一个序列中，取出一个子序列。序列支持切片，即：列表、元组、字符串，均支持进行切片操作。

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

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

• 起始下标表示从何处开始，可以留空，留空视作从头开始
• 结束下标（不含）表示何处结束，可以留空，留空视作截取到结尾
• 步长表示，依次取元素的间隔
• 步长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(f"结果1：{result1}")

# 对tuple进行切片，从头开始，到最后结束，步长1
my_tuple = (0, 1, 2, 3, 4, 5, 6)
result2 = my_tuple[:]     # 起始和结束不写表示从头到尾，步长为1可以省略
print(f"结果2：{result2}")

# 对str进行切片，从头开始，到最后结束，步长2
my_str = "01234567"
result3 = my_str[::2]
print(f"结果3：{result3}")

# 对str进行切片，从头开始，到最后结束，步长-1
my_str = "01234567"
result4 = my_str[::-1]          # 等同于将序列反转了
print(f"结果4：{result4}")

# 对列表进行切片，从3开始，到1结束，步长-1
my_list = [0, 1, 2, 3, 4, 5, 6]
result5 = my_list[3:1:-1]
print(f"结果5：{result5}")

# 对元组进行切片，从头开始，到尾结束，步长-2
my_tuple = (0, 1, 2, 3, 4, 5, 6)
result6 = my_tuple[::-2]
print(f"结果6：{result6}")

7. 集合（set）

不支持元素的重复（自带去重功能）、并且内容无序的容器。（去重且无序）

基本语法：

注意：定义空集合只能用set()，大括号{}已被字典占用

*集合的常用操作 *

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

• 添加新元素：集合.add(元素)。将指定元素，添加到集合内。

• 移除元素：集合.remove(元素)。将指定元素，从集合内移除。

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

• 清空集合：集合.clear()。

• 取出2个集合的差集：集合1.difference(集合2)。取出集合1和集合2的差集（==集合1有而集合2没有的==）

• 消除2个集合的交集：集合1.difference_update(集合2)。删除集合1中和集合2有的元素。（==集合1被修改，集合2不变==）

• 2个集合合并：集合1.union(集合2) 。将集合1和集合2组合成新集合（==并集==）

• 查看集合的元素数量：len(集合)

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

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

集合的特点：

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

"""
演示数据容器集合的使用
"""
# 定义集合
my_set = {"a", "b", "i", "d", "j", "r", "t", "y", "u"}
my_set_empty = set()        # 定义空集合
print(f"my_set的内容是：{my_set}, 类型是：{type(my_set)}")
print(f"my_set_empty的内容是：{my_set_empty}, 类型是：{type(my_set_empty)}")

# 添加新元素
my_set.add("Python")
my_set.add("传智教育")      #
print(f"my_set添加元素后结果是：{my_set}")
# 移除元素
my_set.remove("黑马程序员")
print(f"my_set移除黑马程序员后，结果是：{my_set}")
# 随机取出一个元素
my_set = {"传智教育", "黑马程序员", "itheima"}
element = my_set.pop()
print(f"集合被取出元素是：{element}, 取出元素后：{my_set}")

# 清空集合, clear
my_set.clear()
print(f"集合被清空啦，结果是：{my_set}")

# 取2个集合的差集
set1 = {1, 2, 3}
set2 = {1, 5, 6}
set3 = set1.difference(set2)
print(f"取出差集后的结果是：{set3}")
print(f"取差集后，原有set1的内容：{set1}")
print(f"取差集后，原有set2的内容：{set2}")


# 消除2个集合的差集
set1 = {1, 2, 3}
set2 = {1, 5, 6}
set1.difference_update(set2)
print(f"消除差集后，集合1结果：{set1}")
print(f"消除差集后，集合2结果：{set2}")

# 2个集合合并为1个
set1 = {1, 2, 3}
set2 = {1, 5, 6}
set3 = set1.union(set2)
print(f"2集合合并结果：{set3}")
print(f"合并后集合1：{set1}")
print(f"合并后集合2：{set2}")

# 统计集合元素数量len()
set1 = {1, 2, 3, 4, 5, 1, 2, 3, 4, 5}
num = len(set1)
print(f"集合内的元素数量有：{num}个")

# 集合的遍历
# 集合不支持下标索引，不能用while循环
# 可以用for循环
set1 = {1, 2, 3, 4, 5}
for element in set1:
    print(f"集合的元素有：{element}")

8. 字典（dict)

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

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

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

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

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

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

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

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

"""
演示数据容器字典的定义
"""
# 定义字典
my_dict1 = {"王力鸿": 99, "周杰轮": 88, "林俊节": 77}
# 定义空字典
my_dict2 = {}
my_dict3 = dict()
print(f"字典1的内容是：{my_dict1}, 类型：{type(my_dict1)}")

# 定义重复Key的字典
my_dict1 = {"王力鸿": 99, "王力鸿": 88, "林俊节": 77}
print(f"重复key的字典的内容是：{my_dict1}")

# 从字典中基于Key获取Value
my_dict1 = {"王力鸿": 99, "周杰轮": 88, "林俊节": 77}
score = my_dict1["王力鸿"]
print(f"王力鸿的考试分数是：{score}")

# 定义嵌套字典
stu_score_dict = {
    "王力鸿": {
        "语文": 77,
        "数学": 66,
        "英语": 33
    }, "周杰轮": {
        "语文": 88,
        "数学": 86,
        "英语": 55
    }, "林俊节": {
        "语文": 99,
        "数学": 96,
        "英语": 66
    }
}
print(f"学生的考试信息是：{stu_score_dict}")

# 从嵌套字典中获取数据
score = stu_score_dict["周杰轮"]["语文"]
print(f"周杰轮的语文分数是：{score}")

字典的常用操作：

• 新增元素 语法：字典[Key] = Value
• 更新元素 语法：字典[Key] = Value。（key已存在）
• 删除元素 语法：字典.pop(Key)
• 清空字典 语法：字典.clear()
• 获取全部的key 语法：字典.keys()
• 遍历字典 语法：for key in 字典.keys()
• 计算字典内的全部元素（键值对）数量 语法：len(字典)

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

字典的特点：

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

"""
演示字典的常用操作
"""
my_dict = {"周杰轮": 99, "林俊节": 88, "张学油": 77}
# 新增元素
my_dict["张信哲"] = 66
print(f"字典经过新增元素后，结果：{my_dict}")
# 更新元素
my_dict["周杰轮"] = 33
print(f"字典经过更新后，结果：{my_dict}")
# 删除元素
score = my_dict.pop("周杰轮")
print(f"字典中被移除了一个元素，结果：{my_dict}, 周杰轮的考试分数是：{score}")

# 清空元素, clear
my_dict.clear()
print(f"字典被清空了，内容是：{my_dict}")

# 获取全部的key
my_dict = {"周杰轮": 99, "林俊节": 88, "张学油": 77}
keys = my_dict.keys()
print(f"字典的全部keys是：{keys}")
# 遍历字典
# 方式1：通过获取到全部的key来完成遍历
for key in keys:
    print(f"字典的key是:{key}")
    print(f"字典的value是：{my_dict[key]}")

# 方式2：直接对字典进行for循环，每一次循环都是直接得到key
for key in my_dict:
    print(f"2字典的key是:{key}")
    print(f"2字典的value是：{my_dict[key]}")

# 统计字典内的元素数量, len()函数
num = len(my_dict)
print(f"字典中的元素数量有：{num}个")

9. 字符串的大小比较

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

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

"""
演示字符串大小比较
"""
# abc 比较 abd
print(f"abd大于abc，结果：{'abd' > 'abc'}")
# a 比较 ab
print(f"ab大于a，结果：{'ab' > 'a'}")
# a 比较 A
print(f"a 大于 A，结果：{'a' > 'A'}")
# key1 比较 key2
print(f"key2 > key1，结果：{'key2' > 'key1'}")

10. ASCII码表

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

• 大小写英文单词
• 数字
• 特殊符号(!、\、|、@、#、空格等）

都有其对应的ASCII码表值每一个字符都能对应上一个数字的码值。字符串进行比较就是基于数字的码值大小进行比较的。