05 集合(源于Datawhale)_集合能不能用len()-CSDN博客

本文链接：https://blog.csdn.net/leileixiang/article/details/107721601

Python 中set与dict类似，也是一组key的集合，但不存储value。同样的都是key，所以没有重复的。并且和字典的key一样都是不可变类型。数值、字符串和元组是不可变类型。

1. 集合的创建

方法一: 先创建对象再加入元素，创建空集合的时候要注意只能使用对象=set()，因为对象={}是空字典的形式。

basket = set()
basket.add('apple')
basket.add('banana')
print(basket)  # {'banana', 'apple'}

方法二:直接把一堆元素用花括号括起来{元素1, 元素2, ..., 元素n}。因为键key是不能重复的，所以重复元素在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="ABCADFDCC"
b1=set(b)
print(b1)
# {'B', 'F', 'C', 'D', 'A'}
# 将字符串转化成集合

c = set(("Google", "Lsgogroup", "Taobao", "Taobao")) # 把元组转化成集合
print(b)
# {'Taobao', 'Lsgogroup', 'Google'}
d = set(["Google", "Lsgogroup", "Taobao", "Google"]) # 将列表转化成集合
print(c)
# {'Taobao', 'Lsgogroup', 'Google'}

综上所述：
1.创建集合的方法有:（1）先创建空集合再加入元素（2）直接把一堆元素用花括号括起来（3）使用set(value)工厂函数
2.集合的特点:无序和唯一
3.集合是无序的，无法创建索引也不能切片，也没有利用键来获取集合中元素的值，但是可以判断一个元素是不是在集合中

2. 访问集合中的值

可以使用len()內建函数得到集合的大小。

s = set(['Google', 'Baidu', 'Taobao'])
print(len(s))  # 3

可以使用for把集合中的数据一个个读取出来

s = set(['Google', 'Baidu', 'Taobao'])
for item in s:
    print(item)

# Baidu
# Google
# Taobao

可以通过in或not in判断一个元素是否在集合中已经存在

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

综上所述:
1.使用len()內建函数得到集合的大小
2.使用for把集合中的数据一个个读取
3.通过in或not in判断一个元素是否在集合中已经存在

3. 集合的内置方法

1.set.add(elmnt)
2.set.update(set)
3.set.remove(item)
4.set.discard(value)
5.set.pop()
6.set.union(set1, set2)
7.set1 | set2
8.set.difference(set)
9.set1 - set2
10.set.difference_update(set)
11.set.symmetric_difference(set)
12.set1 ^ set2
13.set.symmetric_difference_update(set)
14.set.issubset(set)
15.set1 <= set2
16.set.issuperset(set)
17.set1 >= set2
18.set.isdisjoint(set)
以下是具体的例子:

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.update(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

说到了集合，可以做数学意义上的交集操作
（6）set.intersection(set1, set2) 返回两个集合的交集。
（7）set1 & set2 返回两个集合的交集。
（8）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) # a和b的交集
print(c)  # {'a', 'c'}
print(a) # {'b', 'a', 'c', 'd', 'r'}
print(b) # {'a', 'c', 'z', 'l', 'm'}

print(a & b)  # {'c', 'a'}  a和b的交集
print(a)  # {'a', 'r', 'c', 'b', 'd'} 不改变a集合本身
print(b) # {'a', 'c', 'z', 'l', 'm'}

a.intersection(b) # 看样子这种写法没有什么用
print(a) # {'c', 'a', 'b', 'r', 'd'}
print(b) # {'a', 'c', 'z', 'l', 'm'}

print(set.intersection(a,b)) # {'a', 'c'}，这种写法有点用
print(a) # {'b', 'a', 'c', 'd', 'r'}
print(b) # {'a', 'c', 'z', 'l', 'm'}

a.intersection_update(b) 
print(a)  # {'a', 'c'}
print(b) # {'a', 'c', 'z', 'l', 'm'}

print(set.difference_update(a,b)) # None
print(a) # set()
print(b) # {'a', 'c', 'z', 'l', 'm'}

c={'a', 'c','e'}
d={'a', 'c', 'z', 'l', 'm'}
print(set.difference_update(c,d)) # None
print(c) # {'e'}
print(d) # {'m', 'a', 'c', 'l', 'z'}

上面可以看到，交集的方法有:
1.set.intersection(a, b) 返回a和b的交集，a和b不会改变
2.a.intersection(b)，返回a和b的交集，a和b不会被改变
3.a&b 返回a和b的交集，a和b不会被改变
~~4.set.intersection(a,b) ，返回a和b的交集，a和b不会被改变~~
5.a.intersection_update(b)，a会改变，b不会被改变，a会保留a和b的交集，删除其他，也就是a会移除和b的不重叠
6.set.difference_update(a,b)，返回None，a和b会删掉a和b的交集，a和b会同时改变

还有并集的操作：
（9）set.union(set1, set2) 返回两个集合的并集。
（10）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'}

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

上面可以看到，并集的方法有：
1.(a | b)是a和b并集
2.a.union(b)是a和b并集
3.set.union(a,b)也是a和b并集

接着是差集和操作
（11）set.difference(set) 返回集合的差集。
（12）set1 - set2 返回集合的差集。
（13）set.difference_update(set) 集合的差集，直接在原来的集合中移除元素，没有返回值

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

c1 = a.difference(b)
print(c1)  # {'b', 'd', 'r'}，a集合减去b集合
print(a - b)  # {'d', 'b', 'r'}
c2 = b.difference(a)
print(c2) # {'l', 'm', 'z'}
print(b - a) # {'l', 'm', 'z'}

print(a)  # {'r', 'd', 'c', 'a', 'b'}
a.difference_update(b) # 可以看到a是发生了变化了
print(a)  # {'d', 'r', 'b'}
print(b) # {'c', 'm', 'a', 'z', 'l'}

综上所述：
(1)a.difference(b)是a-b，同样的b.difference(a)是b-a
(2)a.difference_update(b)没有返回值，会直接改变a，移除和b一样的相同的项目

接着是异或
（14）set.symmetric_difference(set)返回集合的异或。
（15）set1 ^ set2 返回集合的异或。
（16）set.symmetric_difference_update(set)移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。
异或估计就是没有集合a和集合b的交集的集合吧

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

c1 = a.symmetric_difference(b)
print(c1)  # {'m', 'r', 'l', 'b', 'z', 'd'}
c2 = b.symmetric_difference(a)
print(c2) # {'d', 'l', 'b', 'm', 'z', 'r'}

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'} ，发生了改变
print(b) # {'m', 'a', 'z', 'c', 'l'}

综上所述：
（17）a.symmetric_difference(b)，返回a和b的或异，不改变a和b
（18）a ^ b，返回a和b的或异，不改变a和b
（19）a.symmetric_difference_update(b)，返回是None，不过会改变a，不会改变b

集合的包括与被包括
（20）set.issubset(set)判断集合是不是被其他集合包含，如果是则返回 True，否则返回 False。
（21）set1 <= set2 判断集合是不是被其他集合包含，如果是则返回 True，否则返回 False。
（22）set.issuperset(set)用于判断集合是不是包含其他集合，如果是则返回 True，否则返回 False。
（23）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

x = {"f", "e", "d", "c", "b", "a"}
y = {"a", "b", "c"}
z = x.issuperset(y) # x是否包含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

综上所述，包括与被包括：
（1）a.issubset(b)：a集合是否包含于b集合中
（2）a <= b：a集合是否包含于b集合中
（3）a.issuperset(b)：a集合是否包含b集合
（4）a >= b：a集合是否包含b集合

集合的相交
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

综上所述，集合的相交：
（24）a.isdisjoint(b)，有相交的部分返回False，没有相交的部分返回True

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'>

print(list(se)) # [0, 1, 2, 3]
print(se,type(se)) # {0, 1, 2, 3} <class 'set'>

综上所述：
集合转换成列表转换成元组，不改变自己本身
此外可以看到可以用range函数创建集合。

5. 不可变集合

不可改变元素的集合，也就是不能增加或删除元素。
前面带有增加或删除元素的方法一般是带有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'})

6. 题目

1.以下是去除列表的重复元素的两种方法:

temp = []
for item in lst:
    if item not in temp:
        temp.append(item)
print(temp)  # [0, 1, 2, 3, 4, 5]
print('type(temp):',type(temp)) # type(temp): <class 'list'>

a = set(lst)
print("a:",a) # a: {0, 1, 2, 3, 4, 5}
print('type(a)',type(a)) # type(a) <class 'set'>
print(list(a))  # [0, 1, 2, 3, 4, 5]

2.怎么表示只包含⼀个数字1的元组。

tuple_1=(1,)
print(tuple_1,type(tuple_1))
# (1,) <class 'tuple'>

3.创建一个空集合，增加 {‘x’,‘y’,‘z’} 三个元素。

set1=set()
set1.add('x')
set1.add('y')
set1.add('z')
print(set1)
# {'y', 'x', 'z'}

4.列表[‘A’, ‘B’, ‘A’, ‘B’]去重。

list1=['A','B','A','B']
print(list(set(list1))) 
# ['A', 'B']

5.求两个集合{6, 7, 8}，{7, 8, 9}中不重复的元素（差集指的是两个集合交集外的部分）。

set1={6,7,8}
set2={7,8,9}
print(set1^set2)
# {9, 6}

6.求{‘A’, ‘B’, ‘C’}中元素在 {‘B’, ‘C’, ‘D’}中出现的次数。

set1={'A','B','C'}
set2={'B','C','D'}
for i in set1:
    if i in set2:
        print(i,"在set2中出现了一次")
    else:
        print(i,"在set2没有出现")
# C 在set2中出现了一次
# A 在set2没有出现
# B 在set2中出现了一次