{} 集合是一种无序不可重复的序列；集合常用于对两个列表的交并差处理；

集合没有任何获取元素的方法，只用作处理列表或元组的临时数据类型，不适合数据的存储和传输。

1.集合的创建

??利用内置函数set() 或 { }创建；

set_test = set()  # 创建空集合
print(set_test)  # set()
print(type(set_test))  # <class 'set'>

set_test2 = {}
print(set_test2)  # {}
print(type(set_test2))  # <class 'dict'>

set_test3 = {'python', True, 23}
print(set_test3)  # {True, 23, 'python'}

# 用{ }创建集合对象时,集合内元素必须是不可变数据类型
# set_test4 = {[34, 56], [78, 90]}  # TypeError: unhashable type: 'list'
# print(set_test4)
test_list = [34, 56, 34, 90]
set_test5 = set(test_list)
print(set_test5)  # {56, 34, 90} set()方法可以包裹列表，且可帮助列表去重
print(list(set_test5))  # [56, 34, 90] (此时可能想再转回列表,利用列表内置函数list()即可)
# 字典同理
# set_test = {{'name': 'll'}}  # TypeError: unhashable type: 'dict'
# print(set_test)
dict_set = set({'name': 'll'})  # {'name'} 留下的是key值
print(dict_set)

 

2.集合增加元素的操作

??可以利用set.add(元素) 一次增加一个元素；

??利用set.update(可迭代对象) 一次增加多个元素；已经存在的元素不会重复添加；

test_set = {78, 'python', False}
test_set.add(45)
print(test_set)  # {'python', False, 45, 78}
test_set.update(['go', 67])
print(test_set)  # {False, 'go', 67, 45, 78, 'python'}

??

3.集合中删除元素的操作

??set.remove(元素)  删除指定元素；

??set.clear()  清空集合中元素；

??利用python内置函数del ;

test_set = {78, 'python', False}
test_set.remove(78)
print(test_set)  # {'python', False}
# test_set.remove('py')  # KeyError: 'py' (元素不存在时会报错)
test_set.clear()  # set()
print(test_set)
del test_set
print(test_set)  # NameError: name 'test_set' is not defined

 

4.集合的差集

??a, b两个集合，属于a且不属于b的元素集，就是a与b的差集；

??利用difference函数，a.difference(b)可以获取结果； 或直接a - b；

??a.difference_update(b) 将差集结果赋值给a、此时b不变；

a = {34, 'python', True}
b = {34, 89}
print(a.difference(b))  # {True, 'python'}

print(a - b)  # {True, 'python'}

print(a)  # {True, 34, 'python'}
print(id(a))  # 140678808395104
a.difference_update(b)
print(a)  # {True, 'python'}
print(id(a))  # 140678808395104 (a原有的集合对象被修改了)
print(b)  # {89, 34} (集合b未被修改)

 

5.集合的交集

??a,b集合中共有的元素集；

??a.intersection(b, c...)  可以多个集合一起取交集；

??利用&符号, a & b & c；

??a.intersection_update(b, c...)  将交集结果更新到a集合；

a = {34, 'python', True}
b = {34, 89}
c = {'go', 34}
print(a & b & c)  # {34}
print(list(a & b & c)[0])  # 34 (可以将集合先转化为列表，就可以通过索引访问元素了)

print(a.intersection(b, c))  # {34}

a.intersection_update(b, c)
print(a)  # {34}
print(b)  # {89, 34}
print(c)  # {'go', 34}

 

6.集合的并集

??几个集合中所有元素组成的集合；

??a.union(b, c ...) ;

??a  |  b  |  c ;

??a.union_update(b, c ...) ;

a = {34, 'python', True}
b = {34, 89}
c = {'go', 34}
print(a | b | c)  # {True, 34, 'go', 89, 'python'}

print(a.union(b, c))  # {True, 34, 'python', 'go', 89}

# 传入的参数可以是可迭代对象
print(a.union([34, 999]))  # {'python', 34, True, 999}
# 差集和交集参数同样可以是可迭代对象
print(a.difference((34,)))  # {True, 'python'}
print(a.intersection('rtrt'))  # set()

 

7.集合的一些返回值是bool型的函数

??a.isdisjoint(b)  判断两集合是否没有相同元素；

??a.issubset(b) 判断一个集合a是否是集合b 的子集；

??与子集相对，b.issuperset(a) 判断集合b是否是集合a的超集；

a = {34, 'python', True}
b = {34, 89}
print(a.isdisjoint(b))  # False

print(b.isdisjoint({'go'}))  # True

print(b.issubset({34, 89, 90}))  # True

print({34, 89, 90}.issuperset(b))  # True

a = {34, 56, 78}
print(a.isdisjoint([56]))  # False

 

8.对称差集

??只在a和只在b中的元素集合；

??a.symmetric_difference(b)、a.symmetric_difference_update(b)、a ^ b

a = {34, 'python', True}
b = {3