3.数据结构
1.列表
在 Python 中，列表（List）是一种非常常用且灵活的数据结构，它是可变的、有序的元素集合，列表中的元素可以是不同的数据类型，例如整数、字符串、列表等。列表是一种有序序列，list中的元素都是按照顺序排列的。
1. 列表创建
# 1. 直接使用 [] 创建列表
my_list = [1, 2, 3, 4, 5]
# 2. 使用 list() 构造函数
my_list = list((1, 2, 3, 4, 5)) # 传入可迭代对象
# 3. 创建空列表
empty_list = []
empty_list2 = list()
# 4. 使用列表推导式（列表解析）
#[新元素表达式 for 临时变量 in 可迭代对象]
squares = [x**2 for x in range(1, 6)]
# 5. 使用 range() 生成数值列表
numbers = list(range(1, 10, 2)) # 生成 1 到 9，步长为 2
# 6. 创建嵌套列表
nested_list = [[1, 2, 3], [4, 5, 6]]
2. 基本操作
1. 访问列表元素
列表中的元素是有序的，可以通过下标访问元素。列表的下标是从0开始的。列表也可以通过负下标继续倒数访问，最后一个元素下标为-1。
变量 = 列表名 [下标]
示例：
L = ['tom','jcak','lily']
s = L[0]
print(s) # 输出tom
列表元素的下标表示方法可以像变量一样使用，可以进行读取，写入以及计算等操作，成为下标变量。
nums = [1,2,3,4,5]
nums[0] = nums[1] + nums[-1]
print(nums) # 输出[7, 2, 3, 4, 5]
2. 遍历列表
使用for循环遍历
for 循环变量 in 列表名
print(循环变量)
示例：
L = ['tom', 'timi', 'jack']
for s in L:
print(s)
输出：
tom
timi
jack
使用while循环遍历
while 循环变量 < 列表长度
print(列表名[循环变量])
循环变量 = 循环变量 + 1
示例：
L = ['tom', 'timi', 'jack']
s = 0
while s < len(L):
print(L[s])
s = s + 1
输出：
tom
timi
jack
3. 相关方法
列表list是一个类，当一个列表被创建就构成了一个列表对象，可以使用该列表对象调用类的成员方法。
列表名.方法名(参数)
1. append() 方法
在列表末尾添加元素x
格式：
列表名.append(x)
示例：
L = ['tom', 'timi', 'jack']
L.append('lily')
print(L)
输出：
['tom', 'timi', 'jack', 'lily']
2. insert() 方法
在下标i处插入新元素x
格式：
列表名.insert(i,x)
示例：
L = ['tom', 'timi', 'jack']
L.insert(1,'lily')
print(L)
输出：
['tom', 'lily', 'timi', 'jack']
3. extend() 方法
将新列表添加在列表末尾
格式：
列表名.extend(L)
示例：
L1 = ['tom', 'timi', 'jack']
L2 = ['lisa', 'bart', 'adam']
L1.extend(L2)
print(L1)
结果：
['tom', 'timi', 'jack', 'lisa', 'bart', 'adam']
4. remove() 方法
删除列表中与x匹配的元素
格式：
列表名.remove(x)
示例：
L = ['tom', 'timi', 'jack']
L.remove('jack')
print(L)
结果：
['tom', 'timi']
5. pop() 方法
从列表中移除指定下标元素对象，并返回移除元素对象。如果没有参数默认溢出最后一个元素。
格式：
列表名.pop(obj = list[-1])
示例：
L = ['tom', 'timi', 'jack']
s = L.pop(1)
print(L)
print(s)
结果：
['tom', 'jack']
timi
6. index() 方法
返回列表中第一个与x匹配的下标位置。如果没有找到匹配的元素系统会报错。
格式：
列表名.index(x)
示例：
L = ['tom', 'timi', 'jack']
s = L.index('jack')
print(s)
结果：
2
7. count() 方法
返回列表中x元素出现的次数
格式：
列表名.count(x)
示例：
L = ['tom', 'timi', 'jack','timi']
s = L.count('timi')
print(s)
结果：
2
8. reverse() 方法
反转列表元素的位置，即逆序操作
格式：
列表名.reverse()
示例
L = ['tom', 'timi', 'jack']
L.reverse()
print(L)
输出：
['jack', 'timi', 'tom']
9. sort() 方法
对元素进行排序
格式：
列表名.sort(cmp = None,key = None,reverse = None)
cmp 表示自定义的比较函数，默认情况下是升序排序；
key 用来指定元素比较时的关键字，默认情况下直接对元素排序；
reverse 如果复制为True则会对排序后的结果再进行逆序排序。
示例：
L = ['tom', 'timi', 'jack']
L.sort()
print(L)
输出：
['jack', 'timi', 'tom']
上述sort方法对L列表进行了升序排序。 如果指定key值，则可以按照指定的关键字排序：
L = ['tom', 'timi', 'jack']
L.sort(key = len)
print(L)
输出：
['tom', 'timi', 'jack']
key = len 是对每个字符串的长度进行排序。输出结果是按照字符串的长度进行升序排序。
2.元组
在 Python 中，元组（Tuple）是一种不可变的有序序列，与列表类似，但元组一旦创建，其元素就不能被修改、添加或删除。元组通常用于存储一组相关的数据，并且这些数据在程序运行过程中不需要改变。
1. 元组创建
元组使用圆括号来包含元素，元素之间用逗号隔开。
# 方式一：使用圆括号直接创建元组
# 创建一个包含整数的元组
tuple1 = (1, 2, 3)
print(tuple1)
# 创建一个包含不同数据类型的元组
tuple2 = (1, 'hello', True)
print(tuple2)
# 创建一个空元组
empty_tuple = ()
print(empty_tuple)
# 方式二：省略圆括号创建元组
# 省略圆括号创建元组
tuple3 = 4, 5, 6
print(tuple3)
# 单个元素的元组，需要在元素后面加逗号
single_element_tuple = (7,)
print(single_element_tuple)
# 方式三：使用 tuple() 函数创建元组
# 将列表转换为元组
list1 = [8, 9, 10]
tuple4 = tuple(list1)
print(tuple4)
# 将字符串转换为元组
string = "hello"
tuple5 = tuple(string)
print(tuple5)
# 方式四：使用生成器表达式创建元组
# 使用生成器表达式创建元组
tuple6 = tuple(i * 2 for i in range(3))
print(tuple6)
在Python中，要创建一个只包含单个元素的元组，需要在元素后面加上逗号。这是因为圆括号 () 不仅用于定义元组，还用于分组表达式，所以仅使用圆括号包围一个元素，Python会将其解释为普通的表达式，而不是元组。
2. 基本操作
访问和遍历与列表相似。
元组和列表的区别：
元组是不可变的，元组一旦创建完成，就不能对元素进行修改。元组的下标表示方法只能访问元素，不能修改元素。
L1 = ['张三', '李四']
L1[1] = '王五'
print(L1) #['张三', '王五']
T1 = ('张三', '李四')
T1[1] = '王五'
print(T1) #报错
3. 相关方法
元组不可变，没有增加，修改，删除元素的方法。 元组的常用方法有两个：index和count，用法与列表相似。
1. index() 方法
2. count() 方法
3.序列
序列是Python中最基本的数据结构，列表和元组都是序列，都可以使用切片、连接和复制、成员检查、计算长度、取最大值等操作。
1. 切片
切片操作访问一定范围内的元素。
序列名 [i:j:k]
i表示开始索引位置，j表示结束索引位置，k是步长，默认值为1。读取从索引i到所有j-1的所有元素。
# 列表切片操作示例
list_example = list('abcdefg')
# 切片操作：从索引 1 到索引 4（不包含 4），步长为 1
list_slice = list_example[1:4:1]
print("列表切片结果：", list_slice)
# 元组切片操作示例
tuple_example = tuple('abcdefg')
# 切片操作：从索引 2 到索引 5（不包含 5），步长为 1
tuple_slice = tuple_example[2:5:1]
print("元组切片结果：", tuple_slice)
# 字符串切片操作示例
string_example = 'abcdefg'
# 切片操作：从索引 3 到字符串末尾，步长为 2
string_slice = string_example[3::2]
print("字符串切片结果：", string_slice)
列表切片结果： ['b', 'c', 'd']
元组切片结果： ('c', 'd', 'e')
字符串切片结果： df
当步长为负数时表示从右向左。
2. 连接和复制
连接：使用连接操作符 “ + ” 可以把多个相同类型的序列合并在一起，并返回新的序列。 示例：
T1 = ('tom', 123, True)
T2 = ('abc', 456, False)
T3 = T1 + T2
print(T3)
输出：
('tom', 123, True, 'abc', 456, False)
复制：使用 “ * ” 可以把一个序列复制若干次形成新的序列。 示例：
T1 = ('tom', 123, True)
T2 = T1*3
print(T2)
输出：
('tom', 123, True, 'tom', 123, True, 'tom', 123, True)
3. 成员检查
Python提供了两个成员运算符 in 和 not in，用来判断一个元素是否在序列中。返回布尔值。 示例：
T1 = ('tom', 123, True)
print(123 in T1)
输出：
True
4. 内置函数
Python 提供了一些支持序列的内置函数。比如len()、max()、min()等。
len()：计算序列的长度，返回一个整数值
max()：寻找序列的最大值
min()：寻找序列的最小值
5. 元组、列表和字符串的相互转换
list()、tuple()函数可以把字符串转为列表和元组，也可以列表和元组之间转换。
join()函数可以把列表和元组转换为字符串。
T1 = ('tom', 123, True)
L1 = ['jack', 200, False]
S = "hello"
print(list(T1))
print(tuple(L1))
print(list(S))
print(str(T1))
T = [str(item) for item in T1] # 如果元组或列表中的元素包含非字符串类型（如整数、浮点数等），需要先将非字符串元素转换为字符串，再使用 join() 方法。
print(T)
print(" ".join(T))
# print(" ".join(str(item) for item in T1))
str() 函数将元组或列表直接转换为字符串，这种方式会保留元组或列表的原始格式。
4.字典
自带你（dict）使用键值对来存储数据。一个字典中无序存储了若干个条目，每个条目就是一个键值对，关键字在字典中时唯一的，每个关键字匹配一个值，可以使用键来获取相关联的值。
1. 字典创建
用{}来创建字典，键和值之间以冒号隔开，一个键值对被称为一个条目，每个条目用逗号隔开。
{key1:value1,key2:value2,······}
key是关键字，value是值。如果花括号里面没有键值对则会创建一个空字典。
在字典中添加条目的语法为：
dict[键]=值
示例：
d1 = {'1':1, '2':2, '3':3}
print(d1)
d1['4'] = 4
d1['1'] = 5
print(d1)
输出：
{'1': 1, '2': 2, '3': 3}
{'1': 5, '2': 2, '3': 3, '4': 4}
使用dict()函数创建，
# 参数为空会创建空字典
d1 = dict()
print(d1)
# 如果参数为可迭代对象，如列表、元组，则可迭代对象必须成对出现，每个元素的第一项是键，第二项是值
L = [("Adam", 95), ("Lisa", 85), ("Bart", 59)]
d2 = dict(L)
print(d2)
# 如果提供了关键字参数，把关键字参数对应的值添加到字典中。
d3 = dict(red=1, green=2, blue=3)
print(d3)
输出：
{}
{'Adam': 95, 'Lisa': 85, 'Bart': 59}
{'red': 1, 'green': 2, 'blue': 3}
使用字典推导式创建：
{key:value for key,value in 可迭代对象}
示例：
L1 = [("Adam", 95), ("Lisa", 85), ("Bart", 59)]
d1 = {k:v for k,v in L1}
print(d1)
L2 = ['张三','李四','王五']
d2 = {k:L2.index(k) for k in L2}
print(d2)
d3 = {x:x*2 for x in range(1,10)}
print(d3)
输出：
{'Adam': 95, 'Lisa': 85, 'Bart': 59}
{'张三': 0, '李四': 1, '王五': 2}
{1: 2, 2: 4, 3: 6, 4: 8, 5: 10, 6: 12, 7: 14, 8: 16, 9: 18}
列表不能作为字典的键，元组可以，因为键是唯一的，不可变的。
2. 基本操作
1.访问和更新
使用dict[key]的形式查找key对应的value，使用该形式可以访问和更新字典。
# 输出tom对应的值
d1 = {'tom': 10, 'jack': 11, 'rose': 12}
print(d1['tom'])
# 修改tom的值
d1['tom'] = 15
print(d1)
# 添加lily：16条目
d1['lily'] = 16
print(d1)
输出：
10
{'tom': 15, 'jack': 11, 'rose': 12}
{'tom': 15, 'jack': 11, 'rose': 12, 'lily': 16}
2. 遍历字典
d1 = {'tom': 10, 'jack': 11, 'rose': 12}
for k in d1: # 遍历key值，输出key值和对应的value
print(k,d1[k])
3. 删除字典元素
使用del()命令
示例：
d1 = {'tom': 10, 'jack': 11, 'rose': 12}
del d1['tom']
print(d1)
输出：
{'jack': 11, 'rose': 12}
del 字典名可以之间删除字典，当再次print该字典时会报错，找不到字典。
3.相关方法
1. keys()方法
以列表的形式返回字典的所有键。
字典名.keys()
示例：
# 定义一个字典
student = {
'name': 'Alice',
'age': 20,
'gender': 'female',
'major': 'Computer Science'
}
# 打印键视图对象
print(student.keys())
# 将键视图对象转换为列表
print(list(student.keys()))
输出：
dict_keys(['name', 'age', 'gender', 'major'])
['name', 'age', 'gender', 'major']
2. values()方法
以列表形式返回字典所有的值。
字典名.values()
示例：
# 定义一个字典
student = {
'name': 'Alice',
'age': 20,
'gender': 'female'
}
# 获取字典所有值的视图对象
values_view = student.values()
print("值视图对象:", values_view)
# 将值视图对象转换为列表
values_list = list(values_view)
print("值列表:", values_list)
输出：
值视图对象: dict_values(['Alice', 20, 'female'])
值列表: ['Alice', 20, 'female']
3. items()方法
items() 方法返回一个包含字典所有键值对的视图对象，每个键值对以元组形式表示。
示例：
student = {
'name': 'Bob',
'age': 22,
'gender': 'male'
}
# 获取字典所有键值对的视图对象
items_view = student.items()
print("键值对视图对象:", items_view)
# 将键值对视图对象转换为列表
items_list = list(items_view)
print("键值对列表:", items_list)
# 在循环中使用 items() 方法
for key, value in student.items():
print(f"键: {key}, 值: {value}")
输出：
键值对视图对象: dict_items([('name', 'Bob'), ('age', 22), ('gender', 'male')])
键值对列表: [('name', 'Bob'), ('age', 22), ('gender', 'male')]
键: name, 值: Bob
键: age, 值: 22
键: gender, 值: male
4. get()方法
get() 方法用于获取字典中指定键对应的值。如果键不存在，可以返回一个默认值（可选参数）
示例：
student = {
'name': 'Charlie',
'age': 21
}
# 获取存在的键的值
name = student.get('name')
print("姓名:", name)
# 获取不存在的键的值，不指定默认值
city = student.get('city')
print("城市:", city)
# 获取不存在的键的值，指定默认值
city_with_default = student.get('city', 'Unknown')
print("指定默认值的城市:", city_with_default)
输出：
姓名: Charlie
城市: None
指定默认值的城市: Unknown
5. copy()方法
copy() 方法用于创建字典的浅拷贝，即创建一个新的字典对象，但其值如果是可变对象，则仍共享引用。
copy 方法会创建一个新的对象，这个新对象是原对象的浅拷贝。浅拷贝意味着新对象和原对象虽然是不同的对象，但对于原对象中包含的可变子对象（像列表、字典），新对象只是复制了这些子对象的引用，而非对象本身。
示例：
original_dict = {
'key1': [1, 2, 3],
'key2': 'value'
}
# 创建浅拷贝
copied_dict = original_dict.copy()
# 修改原始字典中的可变对象
original_dict['key1'].append(4)
print("原始字典:", original_dict)
print("拷贝字典:", copied_dict) # copy原始字典后，原始字典发生变化，copy后的字典也会发生变化
输出：
原始字典: {'key1': [1, 2, 3, 4], 'key2': 'value'}
拷贝字典: {'key1': [1, 2, 3, 4], 'key2': 'value'}
copy模块中的deepcopy()可以实现深拷贝
copy.deepcopy() 函数会递归地复制对象及其包含的所有子对象，从而创建出完全独立的副本。新对象和原对象没有任何共享的子对象，对原对象的修改不会影响到新对象，反之亦然。当你需要一个完全独立的对象副本，不希望原对象和副本之间有任何相互影响时，应该使用深拷贝。不过，深拷贝的时间和内存开销相对较大，因为它需要递归地复制所有子对象。
6. clear()方法
clear() 方法用于清空字典中的所有键值对，使字典变为空字典。
示例：
student = {
'name': 'David',
'age': 23
}
print("清空之前的字典:", student)
student.clear()
print("清空之后的字典:", student)
输出：
清空之前的字典: {'name': 'David', 'age': 23}
清空之后的字典: {}
7. pop()方法
pop() 方法用于移除字典中指定键的键值对，并返回该键对应的值。如果键不存在，可以返回一个默认值（可选参数）。
示例：
student = {
'name': 'Eve',
'age': 24
}
removed_age = student.pop('age')
print("移除的年龄:", removed_age)
print("移除后的字典:", student)
输出：
移除的年龄: 24
移除后的字典: {'name': 'Eve'}
8. popitem()方法
popitem() 方法用于移除并返回字典中的最后一个键值对（在 Python 3.7 及以后版本中，字典是有序的）。如果字典为空，调用该方法会引发 KeyError。
示例：
student = {
'name': 'Frank',
'age': 25
}
removed_item = student.popitem()
print("移除的键值对:", removed_item)
print("移除后的字典:", student)
输出：
移除的键值对: ('age', 25)
移除后的字典: {'name': 'Frank'}
9. update()方法
实现字典数据更新，无返回值
dict1 = {'a': 1, 'b': 2}
dict2 = {'b': 3, 'c': 4}
dict1.update(dict2)
print(dict1) # 输出: {'a': 1, 'b': 3, 'c': 4}
5.集合
集合(set)是Python中的一种数据结构，与列表相似，可以储存多个数据元素，不同之处是，集合由不同元素组成，且元素存放是无序的。
集合中的元素不能是列表、集合、字典等可变对象。
1. 集合创建
使用{}创建集合，元素用逗号隔开，集合不允许重复元素出现。
示例：
S = {'我','的','世','界','的'}
print(type(S))
print(S)
输出：
<class 'set'>
{'的', '界', '我', '世'}
由于集合是无序的，所以每次输出结果是随机的，与创建时的顺序无关。
使用set()函数创建
set([可迭代对象])
示例：
L1 = ['Adam', 'Lisa', 'Bart']
T1 = ('张三', '李四', '王五')
S1 = set(L1)
S2 = set(T1)
S3 = set()
print(S1)
print(S2)
print(S3)
输出：
{'Lisa', 'Adam', 'Bart'}
{'李四', '张三', '王五'}
set()
使用推导式创建集合
{新元素表达式 for 临时变量 in 可迭代对象}
示例：
S1 = {x*2 for x in range(1,10)}
print(S1)
输出：
{2, 4, 6, 8, 10, 12, 14, 16, 18}
2. 基本操作
1. 访问元素
由于set储存的是无序集合，所以没法通过索引来访问，但是，可以通过for循环遍历集合，访问集合中的每一个元素。
示例：
S1 = {'tom', 'lily', 'rose', 'jim', 'mary'}
print(S1)
for x in S1:
print(x)
输出：
{'mary', 'lily', 'jim', 'rose', 'tom'}
mary
lily
jim
rose
tom
2. 添加元素
add()方法为集合添加元素
示例：
S1 = {'tom', 'lily', 'rose', 'jim', 'mary'}
print(S1)
S1.add('jack')
print(S1)
输出：
{'rose', 'tom', 'jim', 'mary', 'lily'}
{'rose', 'tom', 'jim', 'jack', 'mary', 'lily'}
3. 删除元素
(1)remove() 方法
- 功能：
remove()方法用于从集合中移除指定的元素。如果指定的元素不存在于集合中，会抛出KeyError异常。 - 语法：
set.remove(element)，其中set是要操作的集合，element是要移除的元素。 - 示例代码：
my_set = {1, 2, 3, 4, 5}
print("原始集合:", my_set)
try:
my_set.remove(3)
print("移除元素 3 后的集合:", my_set)
# 尝试移除不存在的元素
my_set.remove(6)
except KeyError:
print("要移除的元素 6 不存在于集合中。")
(2)discard() 方法
- 功能：
discard()方法同样用于从集合中移除指定的元素。与remove()不同的是，如果指定的元素不存在于集合中，discard()方法不会抛出异常，而是直接忽略该操作。 - 语法：
set.discard(element)，其中set是要操作的集合，element是要移除的元素。 - 示例代码：
my_set = {1, 2, 3, 4, 5}
print("原始集合:", my_set)
my_set.discard(3)
print("移除元素 3 后的集合:", my_set)
# 尝试移除不存在的元素
my_set.discard(6)
print("尝试移除不存在的元素 6 后的集合:", my_set)
(3)pop() 方法
- 功能：
pop()方法用于随机移除并返回集合中的一个元素。由于集合是无序的，所以无法预测会移除哪个元素。如果集合为空，调用pop()方法会抛出KeyError异常。 - 语法：
set.pop()，其中set是要操作的集合。 - 示例代码：
my_set = {1, 2, 3, 4, 5}
print("原始集合:", my_set)
popped_element = my_set.pop()
print("移除的元素:", popped_element)
print("移除元素后的集合:", my_set)
# 清空集合后尝试调用 pop()
empty_set = set()
try:
empty_set.pop()
except KeyError:
print("集合为空，调用 pop() 会引发 KeyError 异常。")
(4)clear() 方法
- 功能：
clear()方法用于清空集合中的所有元素，使集合变为空集合。 - 语法：
set.clear()，其中set是要操作的集合。 - 示例代码：
my_set = {1, 2, 3, 4, 5}
print("原始集合:", my_set)
my_set.clear()
print("清空后的集合:", my_set)
(5)del()命令 删除集合本身
S1 = {'tom', 'lily', 'rose', 'jim', 'mary'}
del S1
print(S1)
运行时会报错，提示集合S1不存在
综上所述，当确定要移除的元素一定存在于集合中时，可以使用 remove() 方法；如果不确定元素是否存在，建议使用 discard() 方法；若需要随机移除一个元素，可使用 pop() 方法；而要清空整个集合，则使用 clear() 方法。
3. 集合的运算
1.成员操作
使用in或者not in 操作来判断某个元素是不是在集合中
示例：
S1 = {'tom', 'lily', 'rose', 'jim', 'mary'}
print('tom' in S1)
print('tom' not in S1)
print('jack' not in S1)
输出：
True
False
True
2.比较操作
(1)子集比较（<= 和 <）
<=运算符：用于判断一个集合是否是另一个集合的子集。如果集合A的所有元素都在集合B中，那么A <= B返回True，否则返回False。当A和B元素相同时，A <= B也为True。<运算符：用于判断一个集合是否是另一个集合的真子集。即集合A的所有元素都在集合B中，且B中至少有一个元素不在A中，此时A < B返回True，否则返回False。
示例代码：
A = {1, 2, 3}
B = {1, 2, 3}
C = {1, 2, 3, 4}
# 使用 <= 判断子集关系
print(A <= B) # 输出: True，因为 A 和 B 元素相同
print(A <= C) # 输出: True，因为 A 的元素都在 C 中
# 使用 < 判断真子集关系
print(A < B) # 输出: False，因为 A 和 B 元素相同，不是真子集
print(A < C) # 输出: True，因为 A 是 C 的真子集
(2)超集比较（>= 和 >）
>=运算符：用于判断一个集合是否是另一个集合的超集。如果集合B包含集合A的所有元素，那么B >= A返回True，否则返回False。当A和B元素相同时，B >= A也为True。>运算符：用于判断一个集合是否是另一个集合的真超集。即集合B包含集合A的所有元素，且B中至少有一个元素不在A中，此时B > A返回True，否则返回False。
示例代码：
A = {1, 2, 3}
B = {1, 2, 3}
C = {1, 2, 3, 4}
# 使用 >= 判断超集关系
print(B >= A) # 输出: True，因为 B 和 A 元素相同
print(C >= A) # 输出: True，因为 C 包含 A 的所有元素
# 使用 > 判断真超集关系
print(B > A) # 输出: False，因为 B 和 A 元素相同，不是真超集
print(C > A) # 输出: True，因为 C 是 A 的真超集
(3)集合相等比较（==）
==运算符：用于判断两个集合是否相等。如果两个集合包含的元素完全相同，则返回True，否则返回False。
示例代码：
A = {1, 2, 3}
B = {1, 2, 3}
C = {1, 2, 3, 4}
print(A == B) # 输出: True，因为 A 和 B 元素相同
print(A == C) # 输出: False，因为 A 和 C 元素不同
(4) 集合不相等比较（!=）
!=运算符：用于判断两个集合是否不相等。如果两个集合包含的元素不完全相同，则返回True，否则返回False。
示例代码：
A = {1, 2, 3}
B = {1, 2, 3}
C = {1, 2, 3, 4}
print(A != B) # 输出: False，因为 A 和 B 元素相同
print(A != C) # 输出: True，因为 A 和 C 元素不同
3.交集运算
对于集合A和集合B，交集就是即属于集合A又属于集合B的元素的集合。
在Python中使用 “ & ”来计算两个集合的交集 。
4.并集运算
对于集合A和集合B，并集就是集合A和集合B中所有元素的集合。 在Python中使用 “ | ” 来计算两个集合的并集。
5.差集运算
对于集合A和集合B，所有属于集合A但是不属于集合B的元素的集合。 在Python中使用 “ - ” 来计算两个集合的差集。
6.对称差集运算
对于集合A和集合B，所有属于集合A或者属于B，但是不属于集合A和集合B的交集的集合 在Python中使用 “ ^ ” 来计算两个集合的对称差集。
发表评论