python的集合和字典_python 集合和字典

python的集合

集合的定义

集合（set）是一个无序的、不重复的元素集。它是可变的，意味着你可以在集合中添加或删除元素。集合不支持索引，因为它们是无序的。集合的主要用途包括成员资格测试、删除重复项以及数学上的集合运算，如并集、交集和差集。

创建集合

集合可以通过将逗号分隔的值放在大括号 {} 中或者使用 set() 函数来创建。

# 使用大括号
s = {1, 2, 3}

# 使用 set() 函数
s = set([1, 2, 3])
1
2
3
4
5

集合的基本操作

• 添加元素：add()
• 移除元素：remove()
• 检查元素是否存在：in

s = {1, 2, 3}
s.add(4)         # 添加元素 4
s.remove(2)      # 移除元素 2
print(3 in s)    # 检查元素 3 是否存在，输出 True
1
2
3
4

集合运算

• 并集（Union）：union() 或 |
• 交集（Intersection）：intersection() 或 &
• 差集（Difference）：difference() 或 -
• 对称差集（Symmetric Difference）：symmetric_difference() 或 ^

A = {1, 2, 3}
B = {3, 4, 5}

# 并集
print(A | B)  # 输出 {1, 2, 3, 4, 5}

# 交集
print(A & B)  # 输出 {3}

# 差集
print(A - B)  # 输出 {1, 2}

# 对称差集
print(A ^ B)  # 输出 {1, 2, 4, 5}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

集合推导式

集合推导式是一种简洁的方式来创建集合。

s = {x for x in range(5)}  # 创建一个包含 0 到 4 的集合
1

集合的限制

集合中的元素必须是可哈希的（hashable），这意味着它们必须是不可变类型，如整数、浮点数、字符串、元组等。列表和字典是不可哈希的，因此不能直接用作集合的元素。集合的主要限制包括：

• 元素必须是可哈希的（Hashable）：集合中的元素必须是可以计算出一个固定哈希值的对象。这意味着集合中的元素必须是不可变类型，如整数、浮点数、字符串、元组等。可变类型如列表、字典和集合本身不是可哈希的，因此不能直接作为集合的元素。
• 集合本身是不可哈希的：由于集合是可变的，它们不能作为其他集合的元素或字典的键。
• 不支持索引：由于集合是无序的，因此不能通过索引来访问或修改集合中的元素。
• 不能包含重复元素：集合自动排除重复的元素。如果你尝试添加一个已经存在于集合中的元素，集合将不会发生任何变化。
  下面是一些展示集合限制的例子：

# 创建一个空集合
empty_set = set()

# 尝试添加一个不可哈希的元素（如列表）会导致 TypeError
# invalid_set = { [1, 2, 3] }  # 这会抛出 TypeError

# 集合不能包含自身
# s = {1, 2, 3}
# s.add(s)  # 这会导致 TypeError

# 集合不支持索引
s = {1, 2, 3}
# print(s[0])  # 这会导致 TypeError

# 集合不能包含重复元素
s.add(2)
s.add(2)
print(s)  # 输出仍然是 {1, 2, 3}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

理解集合的限制有助于正确使用这种数据结构，并在编写代码时避免潜在的错误。

集合内置方法

Python的集合（set）类型有一些内置方法，以下是一些主要的内置方法：

• add(element): 向集合中添加一个元素。如果元素已存在，则不会进行任何操作。
• clear(): 移除集合中的所有元素。
• copy(): 返回集合的一个浅复制。
• difference(other): 返回一个新集合，包含所有在集合中但不在其他参数指定的集合中的元素。
• difference_update(other): 移除集合中所有在其他参数指定的集合中出现的元素。
• discard(element): 如果元素在集合中，则移除它。如果元素不在集合中，则不进行任何操作。
• intersection(other): 返回一个新集合，包含所有在集合和其他参数指定的集合中的元素。
• intersection_update(other): 移除集合中所有不在其他参数指定的集合中的元素。
• isdisjoint(other): 如果集合和其他参数指定的集合没有交集，则返回True，否则返回False。
• issubset(other): 如果集合是其他参数指定的集合的子集，则返回True，否则返回False。
• issuperset(other): 如果集合是其他参数指定的集合的超集，则返回True，否则返回False。
• pop(): 移除并返回集合中的一个元素。如果没有元素，则引发一个KeyError。
• remove(element): 移除集合中的一个元素。如果元素不在集合中，则引发一个KeyError。
• symmetric_difference(other): 返回一个新集合，包含所有在集合或其他参数指定的集合中，但不同时在两者中的元素。
• symmetric_difference_update(other): 移除集合中所有在其他参数指定的集合中出现的元素，并添加所有在其他参数指定的集合中但不在集合中的元素。
• union(other): 返回一个新集合，包含所有在集合或其他参数指定的集合中的元素。
• update(other): 向集合中添加所有在其他参数指定的集合中的元素。
  这些方法可以帮助你以不同的方式处理和操作集合数据。

python的字典

字典的定义

字典（dictionary）是一种可变的数据结构，它存储键值对。字典是一种非常有用的数据类型，用于存储和检索数据，其中每个键都映射到一个值。键值对在字典中是无序的，并且在 Python 3.7 及以上版本中，字典保持插入顺序。

创建字典

字典可以通过将键值对放在大括号 {} 中创建，每个键值对由一个键和一个值组成，中间用冒号 : 分隔。键必须是唯一的，并且必须是不可变类型，如字符串、数字或元组。值可以是任何数据类型。

# 使用大括号创建字典
my_dict = {'name': 'Alice', 'age': 25, 'country': 'Wonderland'}

# 使用 dict() 函数创建字典
my_dict = dict(name='Alice', age=25, country='Wonderland')
1
2
3
4
5

访问字典中的值

可以使用键来访问字典中的值。

print(my_dict['name'])  # 输出：Alice
1

修改字典

• 添加键值对：直接赋值
• 修改键对应的值：直接赋值
• 删除键值对：使用 del 关键字

# 添加键值对
my_dict['gender'] = 'Female'

# 修改键对应的值
my_dict['age'] = 26

# 删除键值对
del my_dict['country']
1
2
3
4
5
6
7
8

字典的基本操作

• 获取键列表：keys()
• 获取值列表：values()
• 获取键值对列表：items()
• 检查键是否存在：in

# 获取键列表
print(list(my_dict.keys()))  # 输出：['name', 'age', 'gender']

# 获取值列表
print(list(my_dict.values()))  # 输出：['Alice', 26, 'Female']

# 获取键值对列表
print(list(my_dict.items()))  # 输出：[('name', 'Alice'), ('age', 26), ('gender', 'Female')]

# 检查键是否存在
print('name' in my_dict)  # 输出：True
1
2
3
4
5
6
7
8
9
10
11

字典推导式

字典推导式是一种简洁的方式来创建字典。

# 创建一个字典，键是 1 到 5 的数字，值是数字的平方
squared_dict = {x: x**2 for x in range(1, 6)}
1
2

字典的限制

• 键必须是唯一的。
• 键必须是不可变类型。
• 值可以是任何数据类型，包括可变类型。

字典内置函数

• len(d): 返回字典 d 中项的数量。
• str(d): 返回字典 d 的字符串表示。
• type(obj): 如果 obj 是字典，则返回字典类型。

字典内置方法

• d.clear(): 删除字典 d 中所有的项，使其成为空字典。
• d.copy(): 返回字典 d 的浅拷贝。
• d.fromkeys(seq[, value]): 创建一个新字典，以序列 seq 中的元素作为键，每个键对应的值都是 value。
• d.get(key[, default]): 返回字典 d 中键 key 对应的值，如果键不存在，则返回 default。
• d.items(): 返回一个视图对象，显示字典 d 中的键值对。
• d.keys(): 返回一个视图对象，显示字典 d 中的所有键。
• d.pop(key[, default]): 删除并返回字典 d 中键 key 对应的值，如果键不存在，则返回 default 或引发 KeyError。
• d.popitem(): 随机删除并返回字典 d 中的一个键值对，字典为空时引发 KeyError。
• d.setdefault(key[, default]): 如果键 key 存在于字典 d 中，则返回对应的值。如果不存在，则插入键 key 并将 default 作为值，返回 default。
• d.update([other]): 使用来自字典 other 的键值对更新字典 d。
• d.values(): 返回一个视图对象，显示字典 d 中的所有值。

字典视图对象方法

字典的 keys()、items() 和 values() 方法返回的是视图对象，这些视图对象提供了额外的方法：

• view.add(item): 向视图添加项 item。
• view.clear(): 清空视图中的所有项。
• view.copy(): 返回视图的浅拷贝。
• view.discard(value): 如果值 value 存在于视图中，则移除它。
• view.remove(value): 移除视图中的值 value，如果不存在则引发 KeyError。
• view.pop(): 随机移除并返回视图中的一个元素，如果视图为空则引发 KeyError。

示例

my_dict = {'a': 1, 'b': 2, 'c': 3}

# 获取字典的长度
print(len(my_dict))  # 输出：3

# 获取字典中的所有键
print(my_dict.keys())  # 输出：dict_keys(['a', 'b', 'c'])

# 获取字典中的所有值
print(my_dict.values())  # 输出：dict_values([1, 2, 3])

# 获取字典中的所有键值对
print(my_dict.items())  # 输出：dict_items([('a', 1), ('b', 2), ('c', 3)])

# 获取一个键对应的值
print(my_dict.get('a'))  # 输出：1

# 添加或更新键值对
my_dict.update({'d': 4})
print(my_dict)  # 输出：{'a': 1, 'b': 2, 'c': 3, 'd': 4}

# 删除一个键值对
value = my_dict.pop('a')
print(value)  # 输出：1
print(my_dict)  # 输出：{'b': 2, 'c': 3, 'd': 4}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

这些内置函数和方法使得字典成为 Python 中一个非常强大和灵活的数据结构。