字典（Dictionary）：

定义：

• 字典是 Python 中的一种数据结构，用于存储键值对（key-value pairs）。
• 字典使用花括号 {} 定义，键值对之间用冒号 : 分隔，每对键值对之间用逗号 , 分隔。

特点：

• 字典中的键必须是不可变的（immutable），通常使用字符串或整数作为键。
• 字典中的值可以是任意类型的，包括其他字典或集合。

常用操作：

• 访问元素：可以通过键来访问字典中的值。
• 修改元素：可以通过键来修改字典中的值。
• 添加元素：可以使用新的键值对来添加元素到字典中。
• 删除元素：可以使用 del 关键字或者 pop() 方法删除字典中的元素。
  
  使用关键字参数创建字典：可以通过传递关键字参数来创建一个包含指定键值对的字典。

my_dict = dict(name="Alice", age=30, city="New York")
print(my_dict)  # 输出：{'name': 'Alice', 'age': 30, 'city': 'New York'}

示例：
定义和访问元素：

# 定义一个字典
my_dict = {'name': 'Alice', 'age': 30, 'city': 'New York'}

# 访问字典中的元素
print(my_dict['name'])  # 输出：Alice
print(my_dict['age'])   # 输出：30
print(my_dict['city'])  # 输出：New York

修改元素：

my_dict = {'name': 'Alice', 'age': 30}
other_dict = {'city': 'New York', 'age': 35}

my_dict.update(other_dict)
print(my_dict)  # 输出：{'name': 'Alice', 'age': 35, 'city': 'New York'}

# 修改字典中的元素
my_dict['age'] = 35
print(my_dict['age'])  # 输出：35

添加元素：

# 添加新的键值对到字典中
my_dict['gender'] = 'Female'
print(my_dict)  # 输出：{'name': 'Alice', 'age': 35, 'city': 'New York', 'gender': 'Female'}

删除元素：

pop() 方法用于删除字典中指定键的键值对，并返回该键对应的值。如果指定的键不存在，则可以通过可选的 default 参数指定一个默认值，如果键不存在且没有指定默认值，则会引发 KeyError 错误。

my_dict = {'name': 'Alice', 'age': 30, 'city': 'New York'}

# 删除键为 'age' 的键值对，并返回对应的值
age = my_dict.pop('age')
print(age)  # 输出：30
print(my_dict)  # 输出：{'name': 'Alice', 'city': 'New York'}

# 删除不存在的键，并指定默认值
salary = my_dict.pop('salary', 0)
print(salary)  # 输出：0

popitem() 方法用于随机删除并返回字典中的一个键值对（通常是最后一个键值对）。如果字典为空，则会引发 KeyError 错误。

my_dict = {'name': 'Alice', 'age': 30, 'city': 'New York'}

# 随机删除并返回一个键值对
item = my_dict.popitem()
print(item)  # 输出：('city', 'New York')
print(my_dict)  # 输出：{'name': 'Alice', 'age': 30}

clear() 方法用于删除字典中的所有键值对，即清空字典，但字典对象仍然存在。

my_dict = {'name': 'Alice', 'age': 30, 'city': 'New York'}

# 清空字典
my_dict.clear()
print(my_dict)  # 输出：{}

# 删除字典中的元素
del my_dict['city']
print(my_dict)  # 输出：{'name': 'Alice', 'age': 35, 'gender': 'Female'}

items() 方法
在 Python 中，items() 方法用于返回字典中所有键值对的视图，返回的视图是一个包含键值对的可迭代对象。每个键值对都表示为一个元组，其中第一个元素是键，第二个元素是对应的值。

my_dict = {'name': 'Alice', 'age': 30, 'city': 'New York'}

# 获取字典中所有键值对的视图
items = my_dict.items()
print(items)  # 输出：dict_items([('name', 'Alice'), ('age', 30), ('city', 'New York')])

# 遍历键值对视图
for key, value in items:
    print(f"Key: {key}, Value: {value}")

集合（Set）：

定义：

• 集合是 Python 中的一种数据结构，用于存储无序且唯一的元素。
• 集合使用花括号 {} 定义，元素之间用逗号 , 分隔。

特点：

• 集合中的元素必须是不可变的（immutable），通常使用整数、字符串等不可变类型作为元素。
• 集合中的元素是唯一的，重复的元素会被自动去重。

常用操作：

• 添加元素：可以使用 add() 方法向集合中添加新元素。
• 删除元素：可以使用 remove() 方法删除集合中的元素。
• 集合运算：支持交集、并集、差集等集合运算。
  
  
  
  
  

示例：
定义和添加元素：

# 定义一个集合
my_set = {1, 2, 3, 'a', 'b', 'c'}

# 添加元素到集合中
my_set.add(4)
print(my_set)  # 输出：{1, 2, 3, 4, 'a', 'b', 'c'}

删除元素：

# 从集合中删除元素
my_set.remove('a')
print(my_set)  # 输出：{1, 2, 3, 4, 'b', 'c'}

集合运算：

# 定义两个集合
set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}

# 求交集
intersection = set1.intersection(set2)
print(intersection)  # 输出：{4, 5}

# 求并集
union = set1.union(set2)
print(union)  # 输出：{1, 2, 3, 4, 5, 6, 7, 8}

# 求差集
difference = set1.difference(set2)
print(difference)  # 输出：{1, 2, 3}

set() 函数：

set() 函数用于创建一个可变的集合，它接受一个可迭代对象作为参数，并将其中的元素添加到集合中。如果不传递任何参数给 set() 函数，则会创建一个空集合。

# 创建一个包含多个元素的集合
my_set = set([1, 2, 3, 4, 5])
print(my_set)  # 输出：{1, 2, 3, 4, 5}

# 创建一个空集合
empty_set = set()
print(empty_set)  # 输出：set()

frozenset() 函数：
frozenset() 函数用于创建一个不可变的集合，它接受一个可迭代对象作为参数，并将其中的元素添加到集合中。不可变集合与普通集合的区别在于，不可变集合的内容在创建后不能被修改，也不能添加或删除元素。

# 创建一个包含多个元素的不可变集合
my_frozenset = frozenset([1, 2, 3, 4, 5])
print(my_frozenset)  # 输出：frozenset({1, 2, 3, 4, 5})

& 操作符（交集）：

& 操作符用于计算两个集合的交集，即返回同时存在于两个集合中的元素组成的新集合。

set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}

intersection_set = set1 & set2
print(intersection_set)  # 输出：{4, 5}

【- 】操作符（差集）：

【- 】操作符用于计算两个集合的差集，即返回存在于第一个集合但不存在于第二个集合中的元素组成的新集合。

set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}

difference_set = set1 - set2
print(difference_set)  # 输出：{1, 2, 3}

^ 操作符（对称差）：
^ 操作符用于计算两个集合的对称差，即返回存在于任一集合但不同时存在于两个集合中的元素组成的新集合。

set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}

symmetric_difference_set = set1 ^ set2
print(symmetric_difference_set)  # 输出：{1, 2, 3, 6, 7, 8}