目录

1 集合

1.1 集合的创建

1.2 访问集合中的值

1.3 集合的内置方法

1.4 集合的转换

1.5不可变集合

1 集合

        python中set跟dict类似，也是一组key集合，但是不存储value。
        由于key不能重复，所以在set中没有重复的key。
注意：key为不可变类型，既可哈希的值

num = {}
print(type(num))num = {1,2,3,4}
print(type(num))

1.1 集合的创建

        1.先创建对象再加入元素
        2.在创建空集合时只能使用 s=set(),因为s={}是创建空字典的

basket = set()
basket.add('apple')
basket.add('banana')
print(basket)

        1.直接把一堆元素用花括号括起来{元素1，元素2，元素n}
        2.重复元素在set中会被自动过滤

basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
print(basket) # {'banana', 'apple', 'pear', 'orange'}#使用set(value)工厂函数，把列表转换成集合a = set('abracadabra')
print(a) 
# {'r', 'b', 'd', 'c', 'a'}
b = set(("Google", "Lsgogroup", "Taobao", "Taobao"))
print(b) 
# {'Taobao', 'Lsgogroup', 'Google'}
c = set(["Google", "Lsgogroup", "Taobao", "Google"])
print(c) 
# {'Taobao', 'Lsgogroup', 'Google'}#去掉列表中重复的元素
lst = [0, 1, 2, 3, 4, 5, 5, 3, 1]
temp = []
for item in lst:if item not in temp:temp.append(item)
print(temp) # [0, 1, 2, 3, 4, 5]a = set(lst)
print(list(a)) # [0, 1, 2, 3, 4, 5]

        从结果发现集合的两个提点：无序和唯一
        由于set存储的是无序集合，所以我们不可以为集合创建索引或者执行切片，也没有键可以用来获取元素的值，但是可以判断一个元素是否在集合中

1.2 访问集合中的值

        可以使用len()内建函数获得集合的大小

thisset = set(['google','baidu','taobao'])
print(thisset)

        使用for把集合中的元素一个一个读取

thisset = set(['google','baidu','taobao'])
for item in thisset:print(item)

        通过in或者not in 判断一个元素是否在集合中出现

thisset = set(['Google', 'Baidu', 'Taobao'])
print('Taobao' in thisset) # True
print('Facebook' not in thisset) # True

1.3 集合的内置方法

        set.add(elmnt)用于给集合添加元素，如果添加的元素在集合中已经存在，则不执行操作。

fruits = {"apple", "banana", "cherry"}
fruits.add("orange")
print(fruits) 
# {'orange', 'cherry', 'banana', 'apple'}
fruits.add("apple")
print(fruits) 
# {'orange', 'cherry', 'banana', 'apple'}

        set.updata(set)用于修改当前集合，可以天剑新元素或集合到当前集合。

x = {"apple", "banana", "cherry"}
y = {"google", "baidu", "apple"}
x.update(y)
print(x)
# {'cherry', 'banana', 'apple', 'google', 'baidu'}
y.update(["lsgo", "dreamtech"])
print(y)
# {'lsgo', 'baidu', 'dreamtech', 'apple', 'google'}

        set.remove(item) 用于移除集合中的指定元素，如果元素不在则会发生错误。

fruits = {"apple", "banana", "cherry"}
fruits.remove("banana")
print(fruits) # {'apple', 'cherry'}

        set.discard(value) 用于移除指定的集合元素。 remove() 方法在移除一个不存在的元素时会发生错误，而discard() 方法不会。

fruits = {"apple", "banana", "cherry"}
fruits.discard("banana")
print(fruits) # {'apple', 'cherry'}

        set.pop() 用于随机移除一个元素。

fruits = {"apple", "banana", "cherry"}
x = fruits.pop()
print(fruits) # {'cherry', 'apple'}
print(x) # banana

        由于 set 是无序和无重复元素的集合，所以两个或多个 set 可以做数学意义上的集合操作。
        1. set.intersection(set1, set2 ...) 返回两个集合的交集。
        2. set1 & set2 返回两个集合的交集。
        3. set.intersection_update(set1, set2 ...) 交集，在原始的集合上移除不重叠的元素。

a = set('abracadabra')
b = set('alacazam')
print(a) # {'r', 'a', 'c', 'b', 'd'}
print(b) # {'c', 'a', 'l', 'm', 'z'}
c = a.intersection(b)
print(c) # {'a', 'c'}
print(a & b) # {'c', 'a'}
print(a) # {'a', 'r', 'c', 'b', 'd'}
a.intersection_update(b)
print(a) # {'a', 'c'}

        1.set.union(set1, set2...) 返回两个集合的并集。
        2. set1 | set2 返回两个集合的并集。

a = set('abracadabra')
b = set('alacazam')
print(a) # {'r', 'a', 'c', 'b', 'd'}
print(b) # {'c', 'a', 'l', 'm', 'z'}
print(a | b) # {'l', 'd', 'm', 'b', 'a', 'r', 'z', 'c'}
c = a.union(b)
print(c) # {'c', 'a', 'd', 'm', 'r', 'b', 'z', 'l'}

        1. set.difference(set) 返回集合的差集。
        2. set1 - set2 返回集合的差集。
        3. set.difference_update(set) 集合的差集，直接在原来的集合中移除元素，没有返回值。

a = set('abracadabra')
b = set('alacazam')
print(a) # {'r', 'a', 'c', 'b', 'd'}
print(b) # {'c', 'a', 'l', 'm', 'z'}
c = a.difference(b)
print(c) # {'b', 'd', 'r'}
print(a - b) # {'d', 'b', 'r'}
print(a) # {'r', 'd', 'c', 'a', 'b'}
a.difference_update(b)
print(a) # {'d', 'r', 'b'}

        1. set.symmetric_difference(set) 返回集合的异或。
        2. set1 ^ set2 返回集合的异或。
        3. set.symmetric_difference_update(set) 移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。

a = set('abracadabra')
b = set('alacazam')
print(a) # {'r', 'a', 'c', 'b', 'd'}
print(b) # {'c', 'a', 'l', 'm', 'z'}
c = a.symmetric_difference(b)
print(c) # {'m', 'r', 'l', 'b', 'z', 'd'}
print(a ^ b) # {'m', 'r', 'l', 'b', 'z', 'd'}
print(a) # {'r', 'd', 'c', 'a', 'b'}
a.symmetric_difference_update(b)
print(a) # {'r', 'b', 'm', 'l', 'z', 'd'}

         1. set.issubset(set) 判断集合是不是被其他集合包含，如果是则返回 True，否则返回 False。
        2. set1 <= set2 判断集合是不是被其他集合包含，如果是则返回 True，否则返回 False。

x = {"a", "b", "c"}
y = {"f", "e", "d", "c", "b", "a"}
z = x.issubset(y)
print(z) # True
print(x <= y) # True
x = {"a", "b", "c"}
y = {"f", "e", "d", "c", "b"}
z = x.issubset(y)
print(z) # False
print(x <= y) # False

        1. set.issuperset(set) 用于判断集合是不是包含其他集合，如果是则返回 True，否则返回 False。
        2. set1 >= set2 判断集合是不是包含其他集合，如果是则返回 True，否则返回 False。

x = {"f", "e", "d", "c", "b", "a"}
y = {"a", "b", "c"}
z = x.issuperset(y)
print(z) # True
print(x >= y) # True
x = {"f", "e", "d", "c", "b"}
y = {"a", "b", "c"}
z = x.issuperset(y)
print(z) # False
print(x >= y) # False

        set.isdisjoint(set) 用于判断两个集合是不是不相交，如果是返回 True，否则返回 False。

x = {"f", "e", "d", "c", "b"}
y = {"a", "b", "c"}
z = x.isdisjoint(y)
print(z) # False
x = {"f", "e", "d", "m", "g"}
y = {"a", "b", "c"}
z = x.isdisjoint(y)
print(z) # True

1.4 集合的转换

se = set(range(4))
li = list(se)
tu = tuple(se)
print(se, type(se)) # {0, 1, 2, 3} <class 'set'>
print(li, type(li)) # [0, 1, 2, 3] <class 'list'>
print(tu, type(tu)) # (0, 1, 2, 3) <class 'tuple'>

1.5不可变集合

        Python 提供了不能改变元素的集合的实现版本，即不能增加或删除元素，类型名叫 frozenset 。需要注意的是 frozenset 仍然可以进行集合操作，只是不能用带有 update 的方法。

        frozenset([iterable]) 返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。

a = frozenset(range(10)) # 生成一个新的不可变集合
print(a) 
# frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})
b = frozenset('lsgogroup')
print(b) 
# frozenset({'g', 's', 'p', 'r', 'u', 'o', 'l'})