内置集合类型。集合是一种可变的可迭代的唯一值集合，这些值称为集合的元素。集合的类型名称为 "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 中的所有可变值一样，集合可以被冻结，一旦冻结，所有尝试更新它的后续操作都会失败。
成员
- 添加
- 清除
- 差异
- difference_update
- 舍弃
- 交集
- intersection_update
- isdisjoint
- issubset
- issuperset
- pop
- 移除
- symmetric_difference
- symmetric_difference_update
- union
- update
添加
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
|
必需 设置、可哈希元素的序列或字典。 |