用Python的集合类型进行集合操作（例如，确定联合集、积集和子集）。

商业

Python 提供了一个内置的数据类型，set，它可以处理集合。

类型集是一个非重复元素的集合（非相同值的元素，唯一的元素），可以进行集合操作，如联合集、积集、差集等。

在这一节中，用示例代码解释了集合型集合操作中的基本操作。

  • 创建集合对象: {},set()
  • 集合符号
  • 集合中的元素数量:len()
  • 将一个元素添加到一个集合中:add()
  • 从一个集合中删除一个元素: discard(),remove(),pop(),clear()
  • 瓦塞特(合并，联盟):|操作者,union()
  • 产品集（共同部分、交叉点、交叉点）。:& 运营商,intersection()
  • 相对补充:-操作员,difference()
  • 对称性差集:^ 运营商,symmetric_difference()
  • 子集或不:<=操作者,issubset()
  • 上集与否:>=运算符,issuperset()
  • 确定它们是否互为质数:isdisjoint()

集合类型是一个可以添加和删除元素的可变类型，还有一个frozenset类型，它具有与集合类型相同的集合操作和其他方法，但是是不可变的（不能通过添加、删除或其他方式修改元素）。

创建集合对象。: {}, set()

由波浪括号{}产生的

集合类型的对象可以通过将元素放在大括号{}中来创建。

如果有重复的值，它们会被忽略，只有唯一的值会被保留为元素。

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

print(s)
print(type(s))
# {1, 2, 3, 4}
# <class 'set'>

有可能将不同的类型作为元素。然而，像列表类型这样的可更新对象不能被注册。允许使用图元。

另外，由于集合类型是无序的，所以它们生成的顺序不会被存储。

s = {1.23, 'abc', (0, 1, 2), 'abc'}

print(s)
# {(0, 1, 2), 1.23, 'abc'}

# s = {[0, 1, 2]}
# TypeError: unhashable type: 'list'

不同的类型，如int和float，如果它们的值是相等的，则被视为重复的。

s = {100, 100.0}

print(s)
# {100}

由于空括号{}被认为是一个字典类型，所以可以使用接下来描述的构造函数创建一个空集类型对象（empty set）。

s = {}

print(s)
print(type(s))
# {}
# <class 'dict'>

由构造函数set()生成

set类型的对象也可以用构造函数set()创建。

指定一个可迭代的对象，如列表或元组作为参数，会生成一个集合对象，其元素只能是唯一的值，重复的元素除外。

l = [1, 2, 2, 3, 1, 4]

print(l)
print(type(l))
# [1, 2, 2, 3, 1, 4]
# <class 'list'>

s_l = set(l)

print(s_l)
print(type(s_l))
# {1, 2, 3, 4}
# <class 'set'>

不可变的frozenset类型是通过构造函数frozenset()创建的。

fs_l = frozenset(l)

print(fs_l)
print(type(fs_l))
# frozenset({1, 2, 3, 4})
# <class 'frozenset'>

如果省略该参数，将创建一个空的集合类型对象（空集）。

s = set()

print(s)
print(type(s))
# set()
# <class 'set'>

重复的元素可以用set()从一个列表或元组中删除，但原始列表的顺序不会被保留。

要将一个集合类型转换为列表或元组，请使用list(),tuple()。

l = [2, 2, 3, 1, 3, 4]

l_unique = list(set(l))
print(l_unique)
# [1, 2, 3, 4]

关于在保留顺序的情况下删除重复的元素，只提取重复的元素，以及处理二维数组（列表的列表）中的重复元素，请看下面的文章。

集合符号

除了列表式理解，还有集合式理解。只需将列表理解中的方括号[]替换为大括号{}。

s = {i**2 for i in range(5)}

print(s)
# {0, 1, 4, 9, 16}

关于列表理解符号的更多信息，请参见以下文章。

集合中的元素数量: len()

一个集合中的元素数可以通过内置函数len()获得。

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

print(s)
print(len(s))
# {1, 2, 3, 4}
# 4

如果你想计算每个列表中具有重复值的元素的数量等，请参阅下面的文章。

将一个元素添加到一个集合中: add()

要向一个集合添加一个元素，请使用add()方法。

s = {0, 1, 2}

s.add(3)
print(s)
# {0, 1, 2, 3}

从一个集合中删除一个元素: discard(),remove(),pop(),clear()

要从一个集合中删除一个元素，可以使用discard(), remove(), pop(), and clear()方法。

discard()方法删除了参数中指定的元素。如果指定了一个不存在于集合中的值，则不做任何事情。

s = {0, 1, 2}

s.discard(1)
print(s)
# {0, 2}

s = {0, 1, 2}

s.discard(10)
print(s)
# {0, 1, 2}

remove()方法也会删除参数中指定的元素，但如果指定了一个不存在于集合中的值，则会返回一个错误KeyError。

s = {0, 1, 2}

s.remove(1)
print(s)
# {0, 2}

# s = {0, 1, 2}

# s.remove(10)
# KeyError: 10

pop()方法从一个集合中删除元素并返回它们的值。不可能选择要删除哪些值。一个空的集合将导致一个KeyError错误。

s = {2, 1, 0}

v = s.pop()

print(s)
print(v)
# {1, 2}
# 0

s = {2, 1, 0}

print(s.pop())
# 0

print(s.pop())
# 1

print(s.pop())
# 2

# print(s.pop())
# KeyError: 'pop from an empty set'

clear()方法删除了所有元素，并使集合为空。

s = {0, 1, 2}

s.clear()
print(s)
# set()

瓦塞特(合并，联盟): |操作者, union()

合并集（merger，union）可以通过|操作符或union()方法获得。

s1 = {0, 1, 2}
s2 = {1, 2, 3}
s3 = {2, 3, 4}

s_union = s1 | s2
print(s_union)
# {0, 1, 2, 3}

s_union = s1.union(s2)
print(s_union)
# {0, 1, 2, 3}

可以为一个方法指定多个参数。除了集合类型外，可以通过set()转换为集合类型的列表和图元也可以被指定为参数。这同样适用于后续的操作符和方法。

s_union = s1.union(s2, s3)
print(s_union)
# {0, 1, 2, 3, 4}

s_union = s1.union(s2, [5, 6, 5, 7, 5])
print(s_union)
# {0, 1, 2, 3, 5, 6, 7}

产品集（共同部分、交叉点、交叉点）。: & 运营商, intersection()

可以用&运算符或intersection()方法获得乘积集（公共部分、相交部分和交叉部分）。

s_intersection = s1 & s2
print(s_intersection)
# {1, 2}

s_intersection = s1.intersection(s2)
print(s_intersection)
# {1, 2}

s_intersection = s1.intersection(s2, s3)
print(s_intersection)
# {2}

相对补充: -操作员, difference()

差值集可以通过-运算符或difference()方法获得。

s_difference = s1 - s2
print(s_difference)
# {0}

s_difference = s1.difference(s2)
print(s_difference)
# {0}

s_difference = s1.difference(s2, s3)
print(s_difference)
# {0}

对称性差集: ^ 运营商, symmetric_difference()

对称差集（只包含在两者之一的元素集）可以通过^运算符或symmetric_difference()得到。

相当于逻辑运算中的排他性联结（XOR）。

s_symmetric_difference = s1 ^ s2
print(s_symmetric_difference)
# {0, 3}

s_symmetric_difference = s1.symmetric_difference(s2)
print(s_symmetric_difference)
# {0, 3}

子集或不: <=操作者, issubset()

要确定一个集合是否是另一个集合的子集，可以使用<=操作符或issubset()方法。

s1 = {0, 1}
s2 = {0, 1, 2, 3}

print(s1 <= s2)
# True

print(s1.issubset(s2))
# True

<=操作符和issubset()方法对等价集合都返回真。

要确定它是否是一个真正的子集，请使用<=操作符，它对等价的集合返回false。

print(s1 <= s1)
# True

print(s1.issubset(s1))
# True

print(s1 < s1)
# False

上集与否: >=运算符, issuperset()

要确定一个集合是否是另一个集合的超集，请使用>=操作符或issuperset()。

s1 = {0, 1}
s2 = {0, 1, 2, 3}

print(s2 >= s1)
# True

print(s2.issuperset(s1))
# True

>=操作符和issuperset()方法对于相等的集合都返回真。

要确定它是否是一个真正的超集，请使用>=操作符，它对等价的集合返回错误。

print(s1 >= s1)
# True

print(s1.issuperset(s1))
# True

print(s1 > s1)
# False

确定它们是否互为质数: isdisjoint()

要确定两个集合是否互为质数，可以使用isdisjoint()方法。

s1 = {0, 1}
s2 = {1, 2}
s3 = {2, 3}

print(s1.isdisjoint(s2))
# False

print(s1.isdisjoint(s3))
# True