Python 3.7.1 基础 数据类型 集合 set

一个集合对象是一个包含不同的可哈希对象的无序集合。常见用途包括成员测试，从序列中删除重复项，以及计算数学运算，如交集，并集，差异和对称差异。

集合支持x in set，len(set)和for x in set。作为无序集合，集合不记录元素位置或插入顺序。因此，集合不支持索引，切片或其他类似序列的行为。

目前有两种内置集合类型，set和frozenset。
（1）set类型是可变的-内容可使用类似 add()和remove() 的方法来改变。由于它是可变的，因此它没有哈希值，不能用作字典键或另一个集合的元素。
（2）frozenset类型是不可变的和可散列的 - 其内容在创建后不能更改; 因此，它可以用作字典键或另一个集合的元素。

1. 构造

非空集合（非 frozensets）除了使用set()构造函数之外构造之外，还可以通过在大括号中放置以逗号分隔的元素列表来创建，例如：{'jack', 'sjoerd'}。

两个类的构造函数的工作方式相同：

class set([iterable])
class frozenset([iterable])

返回一个新的set或frozenset对象，其元素取自 iterable。集合的元素必须是可hash的。要表示集合包含集合，内部集合必须是frozenset 对象。如果未指定iterable，则返回新的空集。

译者实例：

def set_constructor():
    mst = set('abc')
    mst1 = set(list([1,2,3]))
    print(mst)
    print(mst1)
    mst2 = set(list([mst,mst1]))
    print(mst2)
# 输出结果
{'a', 'c', 'b'}
{1, 2, 3}
Traceback (most recent call last):
File "xx/list1.py", line 233, in set_constructor
    mst2 = set(list([mst,mst1]))
TypeError: unhashable type: 'set'

def set_constructor2():
    mst3 = frozenset('abc')
    mst4 = frozenset(list([1, 2, 3]))
    mst5 = set(list([mst3, mst4]))
    print(mst5)
    print(type(mst5))
# 输出结果
{frozenset({'b', 'c', 'a'}), frozenset({1, 2, 3})}
<class 'set'>

2. 方法

2.1 set 和 frozenset的公有操作：

len(s)

返回集合s的元素数个数（s的基数）。

扫描二维码关注公众号，回复： 4399860 查看本文章

x in s

测试x是s的成员。

x not in s

测试x不是s的成员。

isdisjoint(other)

如果set与other的交集不为空，则返回True。为空时，返回False。

issubset(other) 或 set <= other

测试set是不是other的子集，是的话返回True，否则False。

set < other

测试set是不是other的真子集 ( 即set <= other and set != other ) ，是的话返回True，否则False 。

def set_opt():
    set1 = set(list([1,2,3,4,5]))
    set2 = set(list([4, 5,6,7,8]))
    set3 = set(list([6, 7, 8,9,0]))
    set4 = set(list([1,2,3,4,5,6]))
    set5 = set(list([1,2,3,4,5]))
    print("len(set1):",len(set1))
    print("3 in set1:" ,3 in set1)
    print("3 in set2",3 in set2)
    print("set1.isdisjoint(set2):",set1.isdisjoint(set2))
    print("set1.isdisjoint(set3):",set1.isdisjoint(set3))
    print("set1.issubset(set2):", set1.issubset(set2))
    print("set1.issubset(set4):",set1.issubset(set4))
    print("set1<=set4:", set1<=set4)
    print("set1<=set5:", set1<=set5)
    print("set1<set5:", set1<set5)
# 输出结果
len(set1): 5
3 in set1: True
3 in set2 False
set1.isdisjoint(set2): False
set1.isdisjoint(set3): True
set1.issubset(set2): False
set1.issubset(set4): True
set1<=set4: True
set1<=set5: True
set1<set5: False

issuperset(other) 或 set >= other

测试ohter集合是不是set的子集，是的话返回True，否则False。。

set > other

测试ohter集合是不是set的真子集（即set >= other and set != other），是的话返回True，否则False。

union(*others) 或 set | other | …

返回set和other（可以指定多个other）的并集。

intersection(*others) 或 set & other & …

返回set和other（可以指定多个other）的交集。

difference(*others) 或 set - other - …

返回一个新集合，其中集合中的元素不在other（可以指定多个other）集合中。

symmetric_difference(other) 或 set ^ other ^ …

返回一个新集合，里面的元素是两者的并集减去交集的结果。

def set_opt2():
    set1 = set(list([1,2,3,4,5]))
    set2 = set(list([1,2,3]))
    set3 = set(list([4, 5,6,7,8]))
    print("set1.issuperset(set2):",set1.issuperset(set2))
    print("set1>=set2:",set1>=set2)
    print("set1.union(set2,set3):",set1.union(set2,set3))
    print("set1|set2|set3:",set1|set2|set3)
    print("set1&set2:",set1&set2)
    print("set1.intersection(set3,set2):",set1.intersection(set3,set2))
    print("set1.difference(set2):",set1.difference(set2))
    print("set3-set1-set2:",set3-set1-set2)
    print("set1^set3",set1^set3)
    set4 = set3.copy()
    print(id(set4),id(set3))
    set3.remove(4)
    print("set3:",set3,"set4:",set4)
# 输出结果
set1.issuperset(set2): True
set1>=set2: True
set1.union(set2,set3): {1, 2, 3, 4, 5, 6, 7, 8}
set1|set2|set3: {1, 2, 3, 4, 5, 6, 7, 8}
set1&set2: {1, 2, 3}
set1.intersection(set3,set2): set()
set1.difference(set2): {4, 5}
set3-set1-set2: {8, 6, 7}
set1^set3 {1, 2, 3, 6, 7, 8}
20633280 20633160
set3: {5, 6, 7, 8} set4: {4, 5, 6, 7, 8}

copy()

返回一个带有s的浅拷贝的新集合。

---

注意，参数为*other的那几个函数将接受任何可迭代的参数。相比之下，他们的或版本（使用操作符如>=）要求他们的参数是集合。这排除了容易出错的结构，例如 set('abc') & 'cbs'比set('abc').intersection('cbs')更有可读性。

set和frozenset都支持各自的比较。

set和frozenset进行比较的时候，根据自己的成员。例如set('abc') == frozenset('abc')返回True， set('abc') in set([frozenset('abc')])也返回True。

子集和相等比较不推广到总排序函数（这句不知道怎么翻he subset and equality comparisons do not generalize to a total ordering function）。例如，任何两个非空不相交的集合不相等，那么彼此的两个子集一定不会相交，所以这几个比较都返回False：a<b， a==b，a>b。

由于集合仅定义了部分排序（子集关系），因此对于集合列表，list.sort()方法的输出是未定义的。

set1 = set(list([1,2,3,4,5]))
set2 = set(list([1,2,3]))
set3 = set(list([4, 5,6,7,8]))
list1 = [set1,set2,set3]
print(list1)
print(list1.sort())
#输出结果
[{1, 2, 3}, {1, 2, 3, 4, 5}, {5, 6, 7, 8}]
None

集合的元素（如字典键）必须是可哈希的。

混合set和frozenset 的二进制操作返回第一个集合的类型。例如frozenset('ab') | set('bc')：返回一个frozenset实例。

---

2.2 只适用于set的方法

update(*others) 或 set |= other | …

更新set集合，添加other中的所有元素。

intersection_update(*others) 或 set &= other & …

更新set集合，添加大家共有的所有元素。

difference_update(*others) 或 set -= other | …

更新set集合，移除set中的所有other中的元素。

symmetric_difference_update(other) 或 set ^= other

更新set集合，里面的元素是两者的并集减去交集的结果。

译者注：本地测试|=,&=,-=,^=都会报错，只能用对应的函数。

def set_opt3_not_for_fronzenset():
    set1 = set(list([1,2,3,4,5]))
    set2 = set(list([1,2,3]))
    set3 = set(list([4, 5,6,7,8]))
    print(set1.update(set2,set3))
    print("set1.update(set2,set3):",set1)
    print(set1.intersection_update(set2))
    print("set1.intersection_update(set2):",set1)
    set1 = set(list([1,2,3,4,5]))
    print(set3.difference_update(set1))
    print("set3.difference_update(set1)",set3)
    print(set1.symmetric_difference_update(set2))
    print("set1.symmetric_difference_update(set2)",set1)
# 输出结果
None
set1.update(set2,set3): {1, 2, 3, 4, 5, 6, 7, 8}
None
set1.intersection_update(set2): {1, 2, 3}
None
set3.difference_update(set1) {6, 7, 8}
None
set1.symmetric_difference_update(set2) {4, 5}

add(elem)

将元素elem添加到集合中。

remove(elem)

从集合中删除元素elem。如果elem未包含在集合中，则引发KeyError。

discard(elem)

如果元素elem存在，则从集合中删除元素elem。

pop()

从集合中删除并返回任意元素。如果集合为空则引发KeyError 。

clear()

从集合中删除所有元素。

def set_opt3_not_for_fronzenset2():
    set1 = set(list([1,2,3,4,5]))
    set1.add(9)
    set1.remove(3)
    set1.discard(100)
    print("set1:",set1)
    print("set1.pop():",set1.pop())
    set1.clear()
    print("set1.clear():",set1)
# 输出结果
set1: {1, 2, 4, 5, 9}
set1.pop(): 1
set1.clear(): set()