集合set

╰半夏微凉° 2024-04-06 13:19 96阅读 0赞

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

s = {
        'x','y''z'}
    
    'w' not in s
    #=> True
    
    'x' not in s
    #=> False

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

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

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

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

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

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

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

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

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

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

{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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1.  找到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

1.  寻找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}

1.  找到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}

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

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

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

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

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

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

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

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

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

1.  将另一个集合中的所有元素添加到一个现有的集合中 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()返回一个新的集合，而不是更新一个现有的集合。 ####

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

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

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

1.  如果一个元素存在，就从一个集合中删除该元素 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

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

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

1.  你能把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'对象不能下标

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

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

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

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

1.  集合和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'

1.  更新一个集合，使之等于它和另一个集合的交集 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}

1.  从第一集合中移除第二集合的交集 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面试问题。