python基础八

集合

• python语言提供的内置数据结构（列表，字典，元组）

• 与列表，字典一样都属于可变类型的序列（可以进行增删改）

• 集合是没有value的字典

集合的创建方式

• 直接{} -> s = {‘python’, ‘hello’, 90}
• 使用内置函数set()

第一种创建方式使用{}

s = {2, 3, 4, 5, 5, 6, 7, 7}   # 集合中的元素不允许重复（与字典一样）
print(s)   # {2, 3, 4, 5, 6, 7}

第二种创建方式使用set()

s1 = set(range(6))
print(s1, type(s1))

s2 = set([1, 2, 4, 5, 5, 5, 6, 6])  # 将列表转化为集合，并且去重
print(s2, type(s2))

s3 = set((1, 2, 4, 4, 5, 65))   # 将元组转化为集合，而且集合中的元素是无序的
print(s3)   # {65, 1, 2, 4, 5}

s4 = set('python')  # 集合中的元素是无序的
print(s4)   # {'o', 'y', 'n', 'p', 't', 'h'}

s5 = set({12, 4, 34, 55, 66, 44, 4})
print(s5, type(s5))     # {34, 66, 4, 55, 12, 44} <class 'set'>

定义一个空集合

s6 = {}     # 空字典
print(type(s6))     # <class 'dict'>

s7 = set()  # 空集合
print(s7, type(s7))     # set() <class 'set'>

集合相关操作

集合元素的判断操作

• in 或 not in

s = {10, 20, 30, 405, 60}
"""集合元素的判断操作"""
print(10 in s)  # True
print(100 in s)     # False
print(10 not in s)  # False
print(100 not in s)     # True

集合元素的新增操作

• 调用add()方法，一次添加一个元素
• 调用update()方法，一次至少添加一个元素

s = {10, 20, 30, 405, 60}
s.add(80)
print(s)    # {80, 20, 405, 10, 60, 30}
s.update({200, 400, 300})   # 在集合里面添加集合
print(s)    # {200, 10, 300, 80, 400, 20, 405, 60, 30}
s.update([100, 99, 8])  # 在集合里面添加列表
s.update((78, 64, 56))  # 在集合里面添加元组
print(s)    # {64, 99, 100, 200, 8, 10, 300, 78, 80, 400, 20, 405, 56, 60, 30}

集合元素的删除操作

• 调用remove()方法，一次删除一个指定元素，如果指定的元素不存在抛出KeyError
• 调用discard()方法，一次删除一个指定元素，如果指定的元素不存在不抛出异常
• 调用pop()方法，一次只删除一个任意元素
• 调用clear()方法，清空集合

"""集合元素的删除操作"""
s = {10, 20, 30, 405, 60}
s.remove(100)
print(s)    # 100被删除
# s.remove(500)
# print(s)    # KeyError: 500
s.discard(500)  # 集合中没有500，但是discard不报错
s.discard(300)  # 删除300
print(s)    # {64, 99, 200, 8, 10, 78, 80, 400, 20, 405, 56, 60, 30}
s.pop()
print(s)    # {99, 200, 8, 10, 78, 80, 400, 20, 405, 56, 60, 30}
s.pop()
print(s)    # {200, 8, 10, 78, 80, 400, 20, 405, 56, 60, 30}
# s.pop(400)
# print(s)    # TypeError: set.pop() takes no arguments (1 given)

s.clear()   # 清空集合中的元素
print(s)    # set()

集合间的关系

两个集合是否相等

• 可以使用运算符 == 或 ！= 进行判断

"""两个集合是否相等，（元素相同，就相等）"""
s = {10, 20, 30, 40}
s2 = {30, 40, 20, 10}
print(s == s2)  # True
print(s != s2)  # False

一个集合是否是另一个集合的子集

• 可以调用方法issubset进行判断
• B是A的子集

"""一个集合是否是另一个集合的子集"""
s1 = {10, 20, 30, 40, 50, 60}
s2 = {10, 20, 30, 40}
s3 = {10, 20, 90}
print(s2.issubset(s1))  # True，s2是s1的子集
print(s3.issubset(s1))  # False，s3不是s1的子集

一个集合是否是另一个集合的超集

• 可以调用方法issuperset进行判断
• A是B的超集

"""一个集合是否是另一个集合的超集"""
print(s1.issuperset(s2))    # True，s1是s2的超集，s1包含于s2
print(s1.issuperset(s3))    # False，s1不是s3的超集，s1不包含于s3

两个集合是否没有交集

• 可以调用方法isdisjoint进行判断

"""两个集合是否含有交集"""
print(s2.isdisjoint(s3))    # False，有交集为False
s4 = {100, 200, 300}
print(s4.isdisjoint(s2))    # True，没有交集为True

集合的数学操作

交集

• 以属于A且属于B的元素为元素的集合称为A与B的交（集）

# 交集
s1 = {10, 20, 30, 40}   # {40, 20, 30}
s2 = {20, 30, 40, 50, 60}   # {40, 20, 30}
print(s1.intersection(s2))
print(s1 & s2)  # intersection()与 & 等价，交集操作
print(s1)   # {40, 10, 20, 30}
print(s2)   # {50, 20, 40, 60, 30}

并集

• 以属于A或属于B的元素为元素的集合称为A与B的并（集）

# 并集
print(s1.union(s2))     # {40, 10, 50, 20, 60, 30}
print(s1 | s2)      # {40, 10, 50, 20, 60, 30}
print(s1)   # {40, 10, 20, 30}
print(s2)   # {50, 20, 40, 60, 30}

差集

• 记A，B是两个集合，则所有属于A且不属于B的元素构成的集合，叫做集合A减集合B(或集合A与集合B之差)

# 差集操作
print(s1.difference(s2))    # {10}
print(s2.difference(s1))    # {50, 60}
print(s1 - s2)  # {10}
print(s1)   # {40, 10, 20, 30}
print(s2)   # {50, 20, 40, 60, 30}

对称差集

• 集合A与集合B的对称差集定义为集合A与集合B中所有不属于A∩B的元素的集合

# 对称差集
print(s1.symmetric_difference(s2))  # {50, 10, 60}
print(s1 ^ s2)  # {50, 10, 60}

集合生成式

用于生成集合的公式

# 列表生成式
lst = [i for i in range(6)]
print(lst)  # [0, 1, 2, 3, 4, 5]

# 集合生成式
set1 = {i * i for i in range(6)}
print(set1)  # {0, 1, 4, 9, 16, 25}

列表，字典，元组，集合总结

数据结构 是否可变 是否重复 是否有序 定义符号
列表(list) 可变 ----- 可重复— 有序--------- []
元组(tuple) 不可变 可重复----有序----------()
字典(dict) 可变 key不可重复 无序 ------{key:value}
———————value可重复

集合(set) 可变-------不可重复----无序--------- {}