013- Python 常用数据类型操作 - 集合

话不多说，上代码，看结果。

print('1、###########################################################')
# 集合
# 无序的, 不可随机访问的, 不可重复的元素集合
# 与数学中集合的概念类似，可对其进行交、并、差、补等逻辑运算
# 分为可变集合和非可变集合
# set 为可变集合  增、删、改
# frozenset   不可变集合  创建好之后, 无法增删改

# 可变集合
s = {1, 2, 3, 1}
print('1、', s, type(s))
# s = set(iterable)  iterable  字符串、列表、元组、字典等
# dict时，只会获取提Key作为set的元素
# s = set((1, 2, 3, 4, 5))   # Function call can be replaced with set literal
s1 = {'asd'}
s2 = set([1, 2, 3])
s3 = set((1, 2, 3, 4, 5))
s4 = set({'性别': '男', '爱好': '女'})
print('2、', s1, type(s1), s2, type(s2), s3, type(s3), s4, type(s4))

# 集合推导式  set(表达式 for 变量 in XX if 条件)
s = set(x + 10 for x in [1, 2, 3] if x != 2)
print('3、', s)

# 不可见集合
# frozenset(iterable)  其中iterable可以是字符串、列表、元组、字典等
# dict时，只会获取提Key作为set的元素
s1 = frozenset('asd')
s2 = frozenset([1, 2, 3])
s3 = frozenset((1, 2, 3, 4, 5))
s4 = frozenset({'性别': '男', '爱好': '女'})
print('4、', s1, type(s1), s2, type(s2), s3, type(s3), s4, type(s4))
# 集合推导式  frozenset(表达式 for 变量 in XX if 条件)
s = frozenset(x + 10 for x in [1, 2, 3] if x != 2)
print('5、', s)

# 创建空集合时 set()或frozenset(),不能s = {} 会被识别成为字典
# 集合中的元素, 必须是可哈希的值   先理解成不可变类型：字符串、元组    列表就不行
# 如果集合中的元素值出现重复, 则会被合并为1个

print('2、单一集合操作###########################################################')
# 可变集合
# 增 s.add(element)  必须保证添加的元素是可哈希的值
s = {1, 2, 3}
a = (0, 1, 2)
s.add(4)
s.add('123')
s.add(a)
# s.add({'性别': '男', '爱好': '女'})   # TypeError: unhashable type: 'dict'
# s.add([0, 1, 2])   # TypeError: unhashable type: 'list'
print('1、', s)

# 删
# 指定删除set对象中的一个元素 s.remove(element)
# 如果集合中没有这个元素，则返回一个错误
s = set((1, 2, 3))
print('2、', s.remove(1), s)
# print(s.remove(12)) # KeyError: 12

# 指定删除集合中的一个元素  s.discard(element)
# 若没有这个元素，则do nothing
s = {1, 2, 3}
print('3、', s.discard(1), s, s.discard(12), s)

# 随机删除并返回一个集合中的元素  s.pop(element)
# 若集合为空，则返回一个错误
s = {1, 2, 3, 4, 5, 6}
s1 = set()  # 空集合
print('4、', s.pop(), s)
# print(s1.pop())  # KeyError: 'pop from an empty set'

# 清空一个集合中的所有元素 s.clear()
s = {1, 2, 3, 4, 5, 6}
print('5、', s.clear(), s)

# 改
# 元素为不可变类型, 不能修改

# 查
# 通过 for in 进行遍历
s = {1, 2, 3, 4, 5, 6}
for value in s:
    print(value, end='\t')
print()

# 通过迭代器进行访问
its = iter(s)
print(next(its))
print(next(its))
print(next(its))
print('##########')
for value in its:
    print(value)

# 不可见集合
# 不能增删改
# 查
# 通过 for in 进行遍历
s = frozenset((1, 2, 3, 4, 5))
for value in s:
    print(value, end='\t')
print()

# 通过迭代器进行访问
its = iter(s)
print(next(its))
print(next(its))
print(next(its))
print('##########')
for value in its:
    print(value)

print('3、集合之间操作###########################################################')
# 交集
# intersection(Iterable)
# Iterable	字符串
# 列表  元组     字典 只判定key     集合
s = {'1', '2', 'asd', 'asdf'}
s1 = {'1', '2'}
s2 = set({'性别': '男', '爱好': '女'})
s3 = set({'性别': '女'})
print('1、', s.intersection(s1))
print('2、', s3.intersection(s2))

# &
s = {'1', '2', 'asd', 'asdf'}
s1 = {'1'}
print('3、', s1 & s)

# 交集计算完毕后, 会再次赋值给原对象  intersection_update()
# 会更改原对象,只适用于可变集合
s = {'1', '2', 'asd', 'asdf'}
s1 = {'1'}
s2 = frozenset(['1', '2'])
print('4、', s.intersection_update(s1), s)
# print(s2.intersection_update(s), s2)  # AttributeError: 'frozenset' object has no attribute 'intersection_update'

# 并集
s1 = {'1', '2'}
s2 = set({'性别': '男', '爱好': '女'})

print('5、', s1.union(s2), s1)
print('6、', s1 | s2, s1)
print('7、', s1.update(s2), s1)

# 差集
s1 = {'1', '2', '3', '4'}
s2 = {'3', '4', '5', '45'}
print('8、', s1.difference(s2), s1, s2)
print('9、', s1 - s2, s1, s2)
print('10、', s1.difference_update(s2), s1, s2)

# 可变与不可变集合混合运算, 返回结果类型以运算符左侧为主
s1 = {'1', '2', '3', '4'}
s2 = frozenset(('3', '4', '5', '45'))
print('11、', type(s1 - s2), type(s2 - s1))

结果图下图。