集合 set：使用一对大括号，元素写在大括号之间，使用逗号分隔

集合中的元素只能是不可变的数据类型，不能是列表、字典和集合

set1 = {1, 2, 3}
set2 = {1, 'a', (1, 2, 3)}
print(type(set1), type(set2))  # <class 'set'> <class 'set'>
print(set1, set2)  # {1, 2, 3} {1, 'a', (1, 2, 3)}

集合自动去重且无序

set3 = {3, 3, 2, 2, 1, 1}
print(set3)        # {1, 2, 3}

集合需要注意以下几点：

1.集合属于可变的数据类型

2.集合有去重功能，对元素自动去重

3.集合的元素只能是不可变的类型（数值、字符串、元组），不能使用列表、字典、集合

4.集合 set 与字典 map，都是以 hash 值分布存储，是无序的数据结构

5.空集合不能直接使用一对大括号，空字典才使用 { }

可以使用 set 创建集合

格式：set(可迭代对象)

对象为字典，获取字典的键 key

set4 = set()
print(type(set4), set4)       # <class 'set'> set()# 对象为字符串，去重且无序
set5 = set('Hello')
print(type(set5), set5)       # <class 'set'> {'H', 'o', 'l', 'e'}# 对象为列表、元组、集合
set6 = set((1, 2))
print(type(set6), set6)       # <class 'set'> {1, 2}# 对象为字典，获取字典的键key
set7 = set({'name': 'zhangsan', 'age': 18})
print(type(set7), set7)       # <class 'set'> {'name', 'age'}

集合的运算与运算符：

交集 &     并集 |     补集 ^     差集 -

交集 & ，返回两个集合中出现相同的元素，intersection

并集 | ，返回两个集合的全部元素，union

补集 ^ ，返回两个集合中不同的元素，symmetric_difference

差集 - ，对两个集合进行减法运算，difference

# 交集 &，返回两个集合中出现相同的元素
s1 = {1, 2, 3, 4, 5}
s2 = {1, 2, 3, 8, 9}
print(s1 & s2)                # {1, 2, 3}
print(s1.intersection(s2))    # {1, 2, 3}# 并集 |，返回两个集合的全部元素
s3 = {1, 2, 3}
s4 = {2, 3, 4}
print(s3 | s4)         # {1, 2, 3, 4}  集合去重
print(s3.union(s4))    # {1, 2, 3, 4}# 补集 ^，返回两个集合中不同的元素
s5 = {1, 2, 3, 4, 5}
s6 = {1, 2, 3}
print(s5 ^ s6)                           # {4, 5}
print(s5.symmetric_difference(s6))       # {4, 5}# 差集 -，对两个集合进行减法运算
s7 = {1, 2, 3, 4, 5}
s8 = {4, 5, 6, 7, 8}
print(s7 - s8)               # {1, 2, 3}
print(s7.difference(s8))     # {1, 2, 3}
print(s8 - s7)               # {8, 6, 7}   集合无序
print(s8.difference(s7))     # {8, 6, 7}

集合更新 update：原集合上更新新集合

集合 1.intersection_update(集合 2)，把交集后的元素更新到集合 1 中

集合 1.update(集合 2)，把并集后的元素更新到集合 1 中

集合 1.symmetric_difference_update(集合 2)，把补集后的元素更新到集合 1 中

集合 1.difference_update(集合 2)，把差集后的元素更新到集合 1 中

# 交集更新
set8 = {1, 2, 3}
set9 = {3, 4, 5}
set8.intersection_update(set9)
print(set8)      # {3}# 并集更新
set8 = {1, 2, 3}
set9 = {3, 4, 5}
set8.update(set9)
print(set8)      # {1, 2, 3, 4, 5}# 补集更新
set8 = {1, 2, 3}
set9 = {3, 4, 5}
set8.symmetric_difference_update(set9)
print(set8)     # {1, 2, 4, 5}# 差集更新
set8 = {1, 2, 3}
set9 = {3, 4, 5}
set8.difference_update(set9)
print(set8)    # {1, 2}

集合增加元素：add(元素)

集合增加的元素只能是不可变的数据类型，比如数值、字符串和元组

不能是列表、字典这些可变的数据类型，否则会报错

set10 = set()      # 空集合
set10.add(1)
set10.add('a')
set10.add((1, 'a'))
print(set10)       # {(1, 'a'), 1, 'a'}

集合元素的删除：

1. pop()，随机删除

2. remove(指定元素)，删除指定元素，元素不存在则报错

set11 = {1, 'a', 2, 'b'}
# remove(指定元素) 删除
print(set11.remove('b'))       # None
print(set11)                   # {1, 2, 'a'}

3. clear()，清空集合的元素，返回空集合

set11 = {1, 'a', 2, 'b'}
# clear()，清空集合的元素，返回空集合
set11.clear()
print(set11)          # set()

4. discard(指定元素)，删除指定元素，元素不存在，不会报错

set11 = {1, 'a', 2, 'b'}
# discard(指定元素)，元素不存在，不会报错
print(set11.discard('c'))     # None
print(set11)                  # {1, 2, 'a', 'b'}

is 开头的函数用来做判断，结果返回布尔值 True、False

集合 1.issubset(集合 2)，判断集合 1 是否是集合 2 的子集，如果是返回 True，不是则返回 False

集合 1.issuperset(集合 2)，判断集合 2 是否是集合 1 的子集，如果是返回 True，不是则返回 False

集合 1.isdisjoint(集合 2)，判断两个集合是否有相同的元素，有相同元素返回 False，没有相同元素返回 True

set12 = {1, 2, 3}
set13 = {1, 2, 3, 4, 5}
# 集合1.issubset(集合2)，判断集合 1 是否是集合 2 的子集
print(set12.issubset(set13))     # True# 集合1.issuperset(集合2)，判断集合 2 是否是集合 1 的子集
print(set13.issuperset(set12))   # True# 集合1.isdisjoint(集合2)，判断两个集合是否有相同的元素，有相同元素返回 False，没有相同元素返回 True
print(set12.isdisjoint(set13))   # False

copy 浅拷贝：

set14 = {1, 2, 3, 4, 5}
set15 = set14.copy()
print(set14, id(set14))    # {1, 2, 3, 4, 5} 2100890355520
print(set15, id(set15))    # {1, 2, 3, 4, 5} 2100890355744
print(set14 is set15)      # False