python sets中的set(集合)/内联set

@[toc](python sets中的set(集合)/内联set)

内置set类型-set，frozenset

set对象是由不同的可hashable对象组成的无序集合。常见的用途包括成员测试、从序列中删除重复项，以及计算诸如交集、并集、差分和对称差分等数学操作。(对于其他容器，请参阅内置的dict、list和tuple类以及collections模块。)

目前有两种内置的set类型，set和frozenset。set类型是可变的——可以使用add()和remove()等方法更改内容。因为它是可变的，所以没有散列值，不能用作字典键或另一个集合的元素。因此，它可以用作字典键或另一个集合的元素。

基本上set模块相同。

set模块简介

set模块提供了用于构造和操作无序的惟一元素集合的类。常见的用途包括成员测试、从序列中删除重复项，以及对集合(如交集、并集、差分和对称差分)计算标准数学操作。

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

大多数set应用程序都使用set类，该类提供除_hash__()之外的所有set方法。对于需要哈希方法的高级应用程序，ImmutableSet类添加了一个_hash__()方法，但是省略了改变集合内容的方法。

集合类是使用字典实现的。因此，对集合元素的要求与字典键的要求相同;也就是说，元素同时定义了_eq__()和_hash__()。因此，集合不能包含列表或字典等可变元素。但是，它们可以包含不可变的集合，比如元组或ImmutableSet的实例。为了方便实现集合集，内部集合自动转换为不可变形式，例如，将集合([Set([‘dog’])]转换为集合([ImmutableSet([‘dog’])])。

class sets.Set([iterable]):
构造一个新的空集对象。如果提供了可选的迭代参数，则使用迭代获得的元素更新集合。iterable中的所有元素都应该是不可变的，或者使用节协议中描述的自动转换为不可变的协议可以转换为不可变的。

class sets.ImmutableSet([iterable]):
构造一个新的空的ImmutableSet对象。如果提供了可选的迭代参数，则使用迭代获得的元素更新集合。iterable中的所有元素都应该是不可变的，或者使用节协议中描述的自动转换为不可变的协议可以转换为不可变的。
因为ImmutableSet对象提供了一个_hash__()方法，所以它们可以用作集合元素或字典键。ImmutableSet对象没有用于添加或删除元素的方法，因此在调用构造函数时必须知道所有元素。

Set 对象

• len(s) 长度
• x in s x是否在s中
• x not in s x不在s中
• s.issubset(t) s是t的子集
• s.issuperset(t) s是t的父集
• s.union(t) s | t 求并集
• s.intersection(t) s & t 求合集
• s.difference(t) s - t 差集
• s.symmetric_difference(t) s ^ t s或t中只有一方有
• s.copy() 一个新的浅拷贝集合

注意，union()、intersection()、difference()和symmetric_difference()的非操作符版本将接受任何可迭代的参数。相反，基于操作符的对应项要求设置参数。这样就排除了容易出错的结构，比如Set(‘abc’)&‘cbs’，而更易于阅读的Set(‘abc’).intersection(‘cbs’)。

此外，Set和ImmutableSet都支持Set to Set比较。当且仅当每个集合的每个元素都包含在另一个集合中时(每个元素都是另一个集合的子集)，两个集合是相等的。当且仅当第一个集合是第二个集合的恰当子集时(是子集，但不相等)，一个集合小于另一个集合。当且仅当第一个集合是第二个集合的适当超集(是超集，但不相等)时，一个集合大于另一个集合。

子集和等式比较不能概括为一个完整的排序函数。例如，任何两个不相交的集合都不相等，并且不是彼此的子集，所以下面所有的都返回False: a<b, a==b，或a>b。因此，set不实现……cmp__()方法。

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

下表列出了ImmutableSet中可用但在Set中没有找到的操作:
hash(s)：返回s的哈希值

这是set中可用，而ImmutableSet不可用的。

注意，update()、intersection_update()、diffence_update()和symmetric_diffence_update()的非操作符版本将接受任何可迭代的参数。

另外，该模块还包含一个union_update()方法，它是update()的别名。包含该方法是为了向后兼容。程序员应该更喜欢update()方法，因为它受到内置的set()和frozenset()类型的支持。

例子：

>>> from sets import Set
>>> engineers = Set(['John', 'Jane', 'Jack', 'Janice'])
>>> programmers = Set(['Jack', 'Sam', 'Susan', 'Janice'])
>>> managers = Set(['Jane', 'Jack', 'Susan', 'Zack'])
>>> employees = engineers | programmers | managers           # union
>>> engineering_management = engineers & managers            # intersection
>>> fulltime_management = managers - engineers - programmers # difference
>>> engineers.add('Marvin')                                  # add element
>>> print engineers # doctest: +SKIP
Set(['Jane', 'Marvin', 'Janice', 'John', 'Jack'])
>>> employees.issuperset(engineers)     # superset test
False
>>> employees.update(engineers)         # update from another set
>>> employees.issuperset(engineers)
True
>>> for group in [engineers, programmers, managers, employees]: # doctest: +SKIP
...     group.discard('Susan')          # unconditionally remove element
...     print group
...
Set(['Jane', 'Marvin', 'Janice', 'John', 'Jack'])
Set(['Janice', 'Jack', 'Sam'])
Set(['Jane', 'Zack', 'Jack'])
Set(['Jack', 'Sam', 'Jane', 'Marvin', 'Janice', 'John', 'Zack'])

自动转换为不可变的协议

集合只能包含不可变的元素。为了方便起见，在将可变集合对象添加为集合元素之前，会自动将可变集合对象复制到一个ImmutableSet。
其机制是始终添加一个可hashable元素，或者如果它不是可hashable元素，则检查该元素是否有一个返回一个不可变等价项的_as_immutable__()方法。
由于Set对象有一个返回ImmutableSet实例的_as_immutable__()方法，所以可以构造集合集合。
contains__所需的一个类似的机制是()和删除()方法需要散列一个元素为加入一组检查。这些方法检查hashability元素,如果不是,检查__as_temporarily_immutable()方法返回的元素包装类,它提供了临时__hash__方法(),eq(),和__ne__ ()。
替代机制避免了构建原始可变对象的单独副本的需要。
Set对象实现了_as_temporarily_immutable__()方法，该方法返回由新类_TemporarilyImmutableSet包装的Set对象。
添加hashability的两种机制通常对用户是不可见的;然而，在多线程环境中可能会出现冲突，其中一个线程正在更新一个集合，而另一个线程将其临时包装在_TemporarilyImmutableSet中。换句话说，可变集集不是线程安全的。

与内置的set类型进行比较

根据从set模块学到的经验，设计了内置的set和frozenset类型。关键的区别在于：

• 将Set和ImmutableSet重命名为Set和frozenset。
• 没有等效的BaseSet。相反，使用isinstance(x， (set, frozenset))。
• 内置的哈希算法对大多数数据集的性能明显更好(冲突更少)。
• 内置版本有更节省空间的pickle。
• 内置版本没有union_update()方法。相反，使用update()方法，它是等价的。
• 内置版本没有_repr(sort =True)方法。相反，使用内置的repr()和ordered()函数:repr(ordered (s))。
• 内置版本没有自动转换为不可变的协议。许多人发现这个特性令人困惑，社区中没有人报告发现它的真正用途。