"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
- difference_update
- discard
- intersection
- intersection_update
- isdisjoint
- issubset
- issuperset
- pop
- remove
- symmetric_difference
- symmetric_difference_update
- union
- update
add
None set.add(element)可以 add 集中已存在的值；这不会更改集。
如果您需要向集中添加多个元素，请参阅 update 或
the |= 扩充赋值运算。
参数
| 参数 | 说明 |
|---|---|
element
|
必需 要添加的元素。 |
clear
None set.clear()difference
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
|
必需 可哈希元素的集合。 |
discard
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
|
必需 要舍弃的元素。必须是可哈希的。 |
intersection
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
remove
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
|
必需 可哈希元素的集合。 |
union
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
|
必需 可哈希元素的集合。 |