python | 数据类型 | 集合

# encoding: utf-8

# 集合
# 无序的，不可随机访问的，不可重复的元素集合
# 可变集合与不可变集合的混合运算，结果和运算符左边的相符
# 定义：可变集合
print({1, 2, 3})
print(set("helloword"))
print(set([1, 2, 3]))
print(set((1, 2, 3)))
# 集合推导式
print(set(x ** 2 for x in range(10)))

# 可变集合的定义
s = frozenset("hello")
s = frozenset([1, 2, 3])
s = frozenset((1, 2, 3))
# 只是根据字典中的key生成的集合
s = frozenset({"name": "admin", "age": 18})
print(s, type(s))

# 可变集合推导式
s = frozenset(x ** 2 for x in range(1, 10) if x % 2 == 0)
print(s, type(s))

# 创建空集合时，使用 set() 或者 frozenset()
s = set()
print(s, type(s))
s = frozenset()
print(s, type(s))

# 集合元素为可哈希值，即不可变类型
# 数值，布尔，字符串，元组
s = {1, True, "hello", (1, 2, 3)}
print(s, type(s))

# 集合中的元素不能重复，如果重复就合并为一个
l = list(set([1, 2, 3, 1]))
print(l, type(l))

# 常用操作
# 增
s = {1, 2, 3, 4}
s.add(5)
print(s)

# 删
# remove()
# 如果没有该元素，则报错
s = {1, 2, 3, 4}
s.remove(3)
print(s)

# discared()
# 如果没有该元素，不会报错
s = {1, 2, 3, 4}
s.discard(3)
print(s)

# pop()
# 随机删除并返回集合中的一个元素
# 如果没有元素删除则会报错
s = {1, 2, 3, 4}
result = s.pop()
print(result, s)

# clear()
# 清空该集合
s = {1, 2, 3, 4}
s.clear()
print(s)

# del
s = {1, 2, 3, 4}
del s

# 遍历
# for in 遍历
s = {1, 2, 3, 4}
for v in s:
    print(v)
# 迭代器遍历
s = {1, 2, 3, 4}
its = iter(s)
# print(next(its))
# print(next(its))
for v in its:
    print(v)

# 集合之间的操作
# intersection 交 &
s1 = {1, 2, 3, 4}
s2 = {3, 4, 5, 6}
result = s1.intersection(s2)
print(result, type(result))
# 可变集合与不可变集合进行交集，结果的类型为intersection左边的类型
s1 = frozenset([1, 2, 3, 4])
s2 = {3, 4, 5, 6}
result = s1.intersection(s2)
print(result, type(result))
# intersection_update 交 结果赋值更新给原集合
# 所以只能用于可变集合
s1 = {1, 2, 3, 4}
s2 = {3, 4, 5, 6}
s1.intersection_update(s2)
print(s1, type(s1))
# intersection(iterable)
print({"1", "2"}.intersection({"1": 89, "3": 90}))

# union 并 |
s1 = {1, 2, 3, 4}
s2 = {3, 4, 5, 6}
result = s1.union(s2)
print(result, type(result))
# 可变集合与不可变集合进行并集，结果的类型为union左边的类型
s1 = frozenset([1, 2, 3, 4])
s2 = {3, 4, 5, 6}
result = s1.union(s2)
print(result, type(result))
# update 并 结果赋值更新给原集合
# 所以只能用于可变集合
s1 = {1, 2, 3, 4}
s2 = {3, 4, 5, 6}
s1.update(s2)
print(s1, type(s1))
# update(iterable)
print({"1", "2"}.union({"1": 89, "3": 90}))

# difference 差 -
s1 = {1, 2, 3, 4}
s2 = {3, 4, 5, 6}
result = s1.difference(s2)
print(result, type(result))
# 可变集合与不可变集合进行并集，结果的类型为union左边的类型
s1 = frozenset([1, 2, 3, 4])
s2 = {3, 4, 5, 6}
result = s1.difference(s2)
print(result, type(result))
# update 并 结果赋值更新给原集合
# 所以只能用于可变集合
s1 = {1, 2, 3, 4}
s2 = {3, 4, 5, 6}
s1.difference_update(s2)
print(s1, type(s1))
# update(iterable)
print({"1", "2"}.difference({"1": 89, "3": 90}))

# 判定
# isdisjoint()
# 是否不相交
s1 = {1, 2, 3, 4}
s2 = {3, 4, 5, 6}
print(s1.isdisjoint(s2))
# issuperset()
# 是否包含另一个集合
s1 = {1, 2, 3, 4}
s2 = {3, 4}
print(s1.issuperset(s2))
# issubset()
# 是否包含于另一个集合
print(s2.issubset(s1))