集合set

35个问题测试你对Python集合的认识 如何通过掌握集合的基本原理来压制算法问题

图片来自Pexels的Andrea Piacquadio 在我追求掌握面试算法的过程中，我发现挖掘Python的基本数据结构是非常有用的。

这是我个人写的问题清单，用来评估我对Python集的了解。

你对Python集的了解程度如何？

1. 将一个对象转换为一个集合是否能保持对象的顺序？ 不，一个集合不是一个有序的数据结构，所以不保持顺序。

看看当我们把列表 [3,2,1] 转换为集合时会发生什么。它变成了{1,2,3}。

a = set([3,2,1])
a 
#=> {1, 2, 3}

2. 检查一个集合是否是另一个集合的子集 这可以用issubset()方法来完成。

a = {4,5}
b = {1,2,3,4,5}

a.issubset(b)
#=> True

b.issubset(a)
#=> False

3. 使用比较运算符，检查一个集合是否是一个子集 如果一个集合s1的所有元素都在s2中，那么它就是s2的一个子集。

如果第一个集合的所有元素都存在于第二个集合中，运算符<=将返回真（又称子集）。

a = {'a','b'}
b = {'a','b','c'}
a <= b
#=> True
b <= a 
#=> False

4. 一个集合是它自己的一个子集吗？ 是的。

因为一个集合包含了自身的所有元素，所以它确实是自身的一个子集。当我们稍后对比 "子集 "和 "适当的子集 "时，理解这一点很重要。

a = {10,20}
a.issubset(a) 
#=> True

5. 检查一个特定的值是否存在于一个集合中 像其他类型的迭代器一样，我们可以用in操作符检查一个值是否存在于一个集合中。

s = {5,7,9}
5 in s
#=> True
6 in s
#=> False

6. 检查一个值是否不在一个集合中 我们可以再次使用in运算符，但这次前面要加上not。

s = {'x','y''z'}

'w' not in s
#=> True

'x' not in s
#=> False

7. 什么是集合？ 集合是一个无序的唯一对象的集合。

当任何对象被转换为一个集合时，重复的值会被删除。

set([1,1,1,3,5])
#=> {1, 3, 5}

根据我的个人经验，我使用集合，因为它们使寻找交叉点、联合点和差异点等操作变得简单。

8. 子集和适当的子集之间有什么区别？ 一个适当的子集是一个集合的子集，不等于它本身。

例如: {1,2,3}是{1,2,3,4}的适当子集。

{1,2,3}不是{1,2,3}的适当子集，但它是一个子集。

9. 检查一个集合是否是一个适当的子集 我们可以用<运算符来检查一个集合是否是另一个集合的适当子集。

{1,2,3} < {1,2,3,4}
#=> True

{1,2,3} < {1,2,3}
#=> False

10. 向一个集合添加一个元素 与列表不同，我们不能用+运算符向集合中添加元素。

{1,2,3} + {4}
#=> TypeError: unsupported operand type(s) for +: 'set' and 'set'
#=> TypeError: +的操作数类型不支持: 'set'和'set'。
Use the add method to add elements.

使用add方法来添加元素。

s = {'a','b','c'}
s.add('d')
s
#=> {'a', 'b', 'c', 'd'}

图片来自Pexels的Jason Villanueva

11. 对一个集合进行复制 copy()方法可以对一个集合进行浅层拷贝。

s1 = {'a', 'b', 'c'}
s2 = s1.copy()
s2 
#=> {'c', 'b', 'a'}

12. 检查一个集合是否是另一个集合的超集 一个集合s1是另一个集合s2的超集，如果s2中的所有值都可以在s1中找到。

你可以用issuperset()方法检查一个集合是否是另一个集合的超集。

a = {10,20,30}
b = {10,20}
a.issuperset(b) #=> True
b.issuperset(a) #=> False

13. 用比较运算符检查一个集合是否是超集 除了issuperset()之外，我们还可以使用>=比较运算符来检查一个集合是否是超集。

a = {10,20,30}
b = {10,20}
a >= b #=> True
b >= a #=> False

14. 一个集合是它自己的超集吗？ 因为一个集合s1中的所有值都在s1中，所以它是自身的超集。尽管它不是一个适当的超集。

a = {10,20,30}
a.issuperset(a) 
#=> True

15. 检查一个集合是否是另一个集合的适当超集 一个集合s1是另一个集合s2的适当超集，如果s2中的所有值都在s1中，并且s1 !=s2。

这可以用>运算符来检查。

a = {10,20,30}
b = {10,20}
c = {10,20}
a > b #=> True
b > c #=> False

16. 将一个集合转换为一个列表 在一个集合上调用 list 构造函数 list()，可以将一个集合转换为一个列表。但是请注意，顺序是不保证的。

a = {4,2,3}
list(a)
#=> [2, 3, 4]

17. 你如何对一个集合中的值进行迭代？ 一个集合可以像其他的迭代器一样用循环来迭代。但是请注意, 顺序是不能保证的.

s = {'a', 'b', 'c', 'd', 'e'}
for i in s:
    print(i)
    
#=> b
#=> c
#=> e
#=> d
#=> a

18. 返回一个集合的长度 一个集合中的元素数量可以用len()函数来返回。

s = {'a', 'b', 'c', 'd', 'e'}
len(s)
#=> 5

19. 创建一个集合 可以使用大括号的集合符号来创建一个集合，如{...}，例如。

{1,2,3}
#=> {1, 2, 3}

或者使用集合构造函数，例如。

# set(1,2,3)
=> TypeError: set预计最多只有1个参数，得到3个参数
set([1,2,3])
#=> {1, 2, 3}

但要注意的是，后者需要传入另一个可迭代的对象，比如一个列表。

20. 找到2个集合的并集。 2个集合的并集可以通过使用union()方法找到。

s1 = {1,2,3,4,5}
s2 = {4,5,6,7,8}
s1.union(s2)
#=> {1, 2, 3, 4, 5, 6, 7, 8}

也可以用|运算符来查找。

s1 = {1,2,3,4,5}
s2 = {4,5,6,7,8}
s1 | s2
#=> {1, 2, 3, 4, 5, 6, 7, 8}

照片：Di Bella Coffee from Pexels

21. 寻找2个集合的交点

2个集合的交集可以用intersection()方法来获取。

s1 = {1,2,3,4,5}
s2 = {4,5,6,7,8}
s1.intersection(s2)
# => {4, 5}

也可以用&操作符来取。

s1 = {1,2,3,4,5}
s2 = {4,5,6,7,8}
s1 & s2
# => {4, 5}

22. 找到s1中不在s2中的元素

这可以用difference()方法找到。

s1 = {1,2,3,4,5}
s2 = {4,5,6,7,8}
s1.difference(s2)
{1, 2, 3}

也可以用-运算符找到。

s1 = {1,2,3,4,5}
s2 = {4,5,6,7,8}
s1 - s2
{1, 2, 3}

23. 从一个集合中删除一个元素

remove()从一个集合中按值删除一个元素。

s = {'x','y','z'}
s.remove('x')
s
#=> {'y', 'z'}

24. 从一个集合中移除并返回一个未指定的元素

pop()从一个集合中移除并返回一个元素，将该集合视为一个无序队列。

s = {'z','y','x'}
s.pop()
s
#=> {'y', 'z'}

25. 检查两个集合是否不相交

如果s1和s2没有共同的元素，那么这两个集合就是不相交的。

a = {1,2,3}
b = {4,5,6}
c = {3}
a.isdisjoint(b) #=> True
a.isdisjoint(c) #=> False

26. 将另一个集合中的所有元素添加到一个现有的集合中 update()方法从另一个集合中添加元素。

a = {1,2,3}
b = {3,4,5}
a.update(b)
a
#=> {1, 2, 3, 4, 5}

这也可以用|=运算符来完成。

a = {1,2,3}
b = {3,4,5}
a |= b
a
#=> {1, 2, 3, 4, 5}

注意这与union不同。

union()返回一个新的集合，而不是更新一个现有的集合。

27. 删除一个集合中的所有元素

clear()将所有元素从一个集合中移除。然后这个集合可以用于未来的操作和存储其他值。

a = {1,2,3}
a.clear()
a
#=> set()

28. 如果一个元素存在，就从一个集合中删除该元素 discard()在一个元素存在的情况下删除该元素，否则不做任何操作。

a = {1,2,3}
a.discard(1)
a
#=> {2, 3}
a = {1,2,3}
a.discard(5)
a
#=> {1, 2, 3}

与此相对应的是remove()，如果你试图删除一个不存在的元素，就会抛出一个错误。

a = {1,2,3}
a.remove(5)
a
#=> KeyError: 5

29. 将一个 dictionary 传递给一个 set 构造函数的结果是什么？ 只有字典的键会存在于返回的集合中。

d = {'狗': 1, '猫': 2, '鱼': 3}。
set(d)
#=> {'猫', '狗', '鱼'}

30. 你能把2个集合压缩在一起吗？ 是的，但是每个集合的值不一定是按顺序连接的。

注意整数集的第一个值是如何与字母集的第三个值（1，'c'）结合在一起的。

z = zip(
  {1,2,3},
  {'a', 'b', 'c'}
)
list(z)
#=> [（1，'c'），（2，'b'），（3，'a'）]

摄影：Meli Di Rocco 来自Pexels 31. 一个集合可以通过索引来访问吗？

不可以。试图通过索引来访问一个集合会产生一个错误。

s = {1,2,3}
s[0]
#=> TypeError: 'set'对象不能下标

32. 集合和元组之间的区别是什么？ 元组是不可变的。集合是可变的。

元组中的值可以通过索引访问。集中的值只能通过值来访问。

元组有顺序。集没有顺序。

集合实现了集合理论，所以它们有很多有趣的功能，比如union、intersect、difference等等。

33. 集合和frozenset之间有什么区别？ Frozenset的行为和集合一样，只是它们是不可变的。

s = set([1,2,3])
fs = frozenset([1,2,3])
s #=> {1, 2, 3}
fs #=> frozenset({1, 2, 3})
s.add(4)
s #=> {1, 2, 3, 4}
fs.add(4)
fs #=> AttributeError: 'frozenset' object has no attribute 'add' 

34. 更新一个集合，使之等于它和另一个集合的交集 intersection_update() 将第一个集合更新为等于交集。

s1 = {1,2,3,4,5}
s2 = {4,5,6,7,8}
s1.intersection_update(s2)
s1
#=> {4, 5}

这也可以用&=操作符来完成。

s1 = {1,2,3,4,5}
s2 = {4,5,6,7,8}
s1 &= s2
s1
#=> {4, 5}

35. 从第一集合中移除第二集合的交集 difference_update()从第一集合中移除交集。

s1 = {1,2,3,4,5}
s2 = {4,5,6,7,8}
s1.difference_update(s2)
s1
#=> {1, 2, 3}

运算符-=也可以。

s1 = {1,2,3,4,5}
s2 = {4,5,6,7,8}
s1 -= s2
s1
#=> {1, 2, 3}

结论 你的表现如何？

说实话，我在这里做得比字符串问题和列表问题还差。

我们在日常编程中并不经常使用集合，大多数人只有在编写SQL连接时才会接触到集合理论。尽管如此，熟悉基础知识也无妨。

如果你觉得这篇文章有趣，你可能也会喜欢我的Python面试问题。

向前走，向上走。