内置集合类型。集是可变的、可迭代的唯一值集合，即集的元素。集合的类型名称为 "set"。
集提供恒定时间操作，用于插入、移除或检查值是否存在。集合是使用哈希表实现的，因此，与字典的键一样，集合的元素必须可哈希化。只有当某个值可以用作字典的键时，才能用作集合的元素。
您可以使用 set() 内置函数构建集合，该函数会返回一个包含其可选参数（必须是可迭代的）的唯一元素的新集合。在不使用参数的情况下调用 set() 会构建一个空集。集没有字面量语法。
in 和 not in 操作用于检查某个值是否在某个集合中：
s = set(["a", "b", "c"]) "a" in s # True "z" in s # False
集合是可迭代的，因此可以用作 for 循环、列表推导式和对可迭代对象进行操作的各种内置函数的运算对象。您可以使用 len() 内置函数检索其长度，而迭代顺序是元素首次添加到集合中的顺序：
s = set(["z", "y", "z", "y"])
len(s) # prints 2
s.add("x")
len(s) # prints 3
for e in s:
print e # prints "z", "y", "x"
在布尔上下文中使用的集合只有在非空时才为 true。
s = set() "non-empty" if s else "empty" # "empty" t = set(["x", "y"]) "non-empty" if t else "empty" # "non-empty"
您可以使用 == 和 != 比较集合是否相等或不等。当且仅当 t 是包含相同元素的集合时，集合 s 才等于 t；迭代顺序不重要。具体而言，集合不等于其元素的列表。集合不会相对于其他集合进行排序，如果尝试使用 <、<=、>、>= 比较两个集合，或者对一组集合进行排序，将会失败。
set() == set() # True set() != [] # True set([1, 2]) == set([2, 1]) # True set([1, 2]) != [1, 2] # True
对两个集合执行 | 操作会返回这两个集合的并集：一个集合，其中包含在任一原始集合或两个原始集合中找到的元素。
set([1, 2]) | set([3, 2]) # set([1, 2, 3])
对两个集合执行 & 运算会返回这两个集合的交集：一个仅包含两个原始集合中都存在的元素的集合。
set([1, 2]) & set([2, 3]) # set([2]) set([1, 2]) & set([3, 4]) # set()
对两个集合执行 - 运算会返回这两个集合的差集：一个集合，其中包含在左侧集合中找到但未在右侧集合中找到的元素。
set([1, 2]) - set([2, 3]) # set([1]) set([1, 2]) - set([3, 4]) # set([1, 2])
对两个集合执行 ^ 运算会返回这两个集合的对称差集：一个集合，其中包含仅在两个原始集合中的一个中找到的元素，但不在两个集合中都找到的元素。
set([1, 2]) ^ set([2, 3]) # set([1, 3]) set([1, 2]) ^ set([3, 4]) # set([1, 2, 3, 4])
在上述每项运算中，生成的集合的元素会保留两个运算数集的顺序，其中从左侧提取的所有元素的顺序都排在仅存在于右侧的任何元素之前。
相应的增强型赋值 |=、&=、-= 和 ^= 会修改左侧集合。
s = set([1, 2]) s |= set([2, 3, 4]) # s now equals set([1, 2, 3, 4]) s &= set([0, 1, 2, 3]) # s now equals set([1, 2, 3]) s -= set([0, 1]) # s now equals set([2, 3]) s ^= set([3, 4]) # s now equals set([2, 4])
与 Starlark 中的所有可变值一样，集合也可以冻结，一旦冻结，所有尝试更新它的后续操作都会失败。
成员
- add
- clear
- 差异
- difference_update
- 舍弃
- 交叉
- intersection_update
- isdisjoint
- issubset
- issuperset
- pop
- 移除
- symmetric_difference
- symmetric_difference_update
- union
- update
add
None set.add(element)可以对集合中已有的值执行 add 操作；这样集合将保持不变。
如果您需要向集合添加多个元素，请参阅 update 或 |= 增强型赋值运算。
参数
| 参数 | 说明 |
|---|---|
element
|
必需 要添加的元素。 |
清除
None set.clear()差值
set set.difference(*others)
如果 s 和 t 是集合，则 s.difference(t) 等同于 s - t；不过请注意，- 运算要求左右两边都是集合，而 difference 方法还接受序列和字典。
可以不使用任何参数调用 difference；这会返回集合的副本。
例如：
set([1, 2, 3]).difference([2]) # set([1, 3]) set([1, 2, 3]).difference([0, 1], [3, 4]) # set([2])
参数
| 参数 | 说明 |
|---|---|
others
|
必需 可哈希元素的集合、序列或字典。 |
difference_update
None set.difference_update(*others)如果 s 和 t 是集合，s.difference_update(t) 等同于 s -= t；不过请注意，-= 增强型赋值要求左右两侧均为集合，而 difference_update 方法还接受序列和字典。
可以不使用任何参数调用 difference_update；这样，集合将保持不变。
例如：
s = set([1, 2, 3, 4]) s.difference_update([2]) # None; s is set([1, 3, 4]) s.difference_update([0, 1], [4, 5]) # None; s is set([3])
参数
| 参数 | 说明 |
|---|---|
others
|
必需 可哈希元素的集合、序列或字典。 |
舍弃
None set.discard(element)可以对集合中不存在的值执行 discard 操作；这样集合将保持不变。如果您希望在尝试移除不存在的元素时失败，请改用 remove。如果您需要从集合中移除多个元素，请参阅 difference_update 或 -= 增强型赋值运算。
例如：
s = set(["x", "y"])
s.discard("y") # None; s == set(["x"])
s.discard("y") # None; s == set(["x"])
参数
| 参数 | 说明 |
|---|---|
element
|
必需 要舍弃的元素。必须可哈希化。 |
交集
set set.intersection(*others)
如果 s 和 t 是集合，则 s.intersection(t) 等同于 s & t；不过请注意，& 运算要求左右两边都是集合，而 intersection 方法还接受序列和字典。
可以不使用任何参数调用 intersection；这会返回集合的副本。
例如：
set([1, 2]).intersection([2, 3]) # set([2]) set([1, 2, 3]).intersection([0, 1], [1, 2]) # set([1])
参数
| 参数 | 说明 |
|---|---|
others
|
必需 可哈希元素的集合、序列或字典。 |
intersection_update
None set.intersection_update(*others)如果 s 和 t 是集合，则 s.intersection_update(t) 等同于 s &= t；不过请注意，&= 增强型赋值要求两边都是集合，而 intersection_update 方法还接受序列和字典。
可以不使用任何参数调用 intersection_update；这样，集合将保持不变。
例如：
s = set([1, 2, 3, 4]) s.intersection_update([0, 1, 2]) # None; s is set([1, 2]) s.intersection_update([0, 1], [1, 2]) # None; s is set([1])
参数
| 参数 | 说明 |
|---|---|
others
|
必需 可哈希元素的集合、序列或字典。 |
isdisjoint
bool set.isdisjoint(other)
例如：
set([1, 2]).isdisjoint([3, 4]) # True set().isdisjoint(set()) # True set([1, 2]).isdisjoint([2, 3]) # False
参数
| 参数 | 说明 |
|---|---|
other
|
必需 一个集合、一个可哈希元素序列或一个字典。 |
issubset
bool set.issubset(other)
请注意，集合始终被视为自身的子集。
例如：
set([1, 2]).issubset([1, 2, 3]) # True set([1, 2]).issubset([1, 2]) # True set([1, 2]).issubset([2, 3]) # False
参数
| 参数 | 说明 |
|---|---|
other
|
必需 一个集合、一个可哈希元素序列或一个字典。 |
issuperset
bool set.issuperset(other)
请注意，集合始终被视为自身的超集。
例如：
set([1, 2, 3]).issuperset([1, 2]) # True set([1, 2, 3]).issuperset([1, 2, 3]) # True set([1, 2, 3]).issuperset([2, 3, 4]) # False
参数
| 参数 | 说明 |
|---|---|
other
|
必需 一个集合、一个可哈希元素序列或一个字典。 |
pop
unknown set.pop()
如果集合为空，则失败。
例如：
s = set([3, 1, 2]) s.pop() # 3; s == set([1, 2]) s.pop() # 1; s == set([2]) s.pop() # 2; s == set() s.pop() # error: empty set
移除
None set.remove(element)如果集合中不存在该元素，remove 将失败。如果您不希望在尝试移除不存在的元素时失败，请改用 discard。如果您需要从集合中移除多个元素，请参阅 difference_update 或 -= 增强型赋值操作。
参数
| 参数 | 说明 |
|---|---|
element
|
必需 要移除的元素。必须是集合的元素（且可哈希化）。 |
symmetric_difference
set set.symmetric_difference(other)
如果 s 和 t 是集合，则 s.symmetric_difference(t) 等同于 s ^ t；不过请注意，^ 运算要求左右两侧均为集合，而 symmetric_difference 方法还接受序列或字典。
例如：
set([1, 2]).symmetric_difference([2, 3]) # set([1, 3])
参数
| 参数 | 说明 |
|---|---|
other
|
必需 一个集合、一个可哈希元素序列或一个字典。 |
symmetric_difference_update
None set.symmetric_difference_update(other)如果 s 和 t 是集合，s.symmetric_difference_update(t) 等同于 `s ^= t; however, note that the ^=` 增强型赋值要求左右两侧均为集合，而 symmetric_difference_update 方法还接受序列或字典。
例如：
s = set([1, 2]) s.symmetric_difference_update([2, 3]) # None; s == set([1, 3])
参数
| 参数 | 说明 |
|---|---|
other
|
必需 一个集合、一个可哈希元素序列或一个字典。 |
并集
set set.union(*others)
如果 s 和 t 是集合，则 s.union(t) 等同于 s | t；不过请注意，| 运算要求左右两边都是集合，而 union 方法还接受序列和字典。
可以不使用任何参数调用 union；这会返回集合的副本。
例如：
set([1, 2]).union([2, 3]) # set([1, 2, 3])
set([1, 2]).union([2, 3], {3: "a", 4: "b"}) # set([1, 2, 3, 4])
参数
| 参数 | 说明 |
|---|---|
others
|
必需 可哈希元素的集合、序列或字典。 |
update
None set.update(*others)例如：
s = set() s.update([1, 2]) # None; s is set([1, 2]) s.update([2, 3], [3, 4]) # None; s is set([1, 2, 3, 4])
如果 s 和 t 是集合，s.update(t) 等同于 s |= t；不过请注意，|= 增强型赋值要求左右两侧均为集合，而 update 方法还接受序列和字典。
允许不使用任何参数调用 update；这样会使集合保持不变。
参数
| 参数 | 说明 |
|---|---|
others
|
必需 可哈希元素的集合、序列或字典。 |