Python基础：05集合类型

Python中，集合对象是一组无序排列的可哈希的值。所以集合成员可以做字典中的键。集合中的元素都是唯一的。

集合(sets)有两种不同的类型，可变集合(set) 和 不可变集合(frozenset)。对可变集合(set)，可以添加和删除元素，对不可变集合(frozenset)则不允许这样做。

请注意，可变集合(set)不是可哈希的，因此既不能用做字典的键也不能做其他集合中的元素。不可变集合(frozenset)则正好相反，即，他们有哈希值，能被用做字典的键或是作为集合中的一个成员。

一：创建集合类型

集合与列表( [ ] )和字典( { } ) 不同，没有特别的语法格式。集合的工厂方法 set() 和 frozenset()，是创建集合的唯一方法：

>>> s = set('cheeseshop')
>>> s
set(['c', 'e', 'h', 'o', 'p', 's'])               #注意，只有一个'e'
 
>>> t = frozenset('bookshop')
>>> t
frozenset(['b', 'h', 'k', 'o', 'p', 's'])

二：访问集合中的值

集合不支持索引访问：

>>> asd
set(['a', 'c', 'b', 'e', 'd'])
 
>>> asd[1]
Traceback (most recent call last):
File "<stdin>", line 1, in<module>
TypeError: 'set' object does not supportindexing

可以遍历查看集合成员或检查某项元素是否是一个集合中的成员：

>>> for i in s:
... print i
...
c
e
h
o
p
s

三：更新集合

用各种集合内建的方法和操作符添加和删除集合的成员：

>>> s.add('z')
>>> s
set(['c', 'e', 'h', 'o', 'p', 's', 'z'])
>>> s.update('pypi')
>>> s
set(['c', 'e', 'i', 'h', 'o', 'p', 's','y', 'z'])
>>> s.remove('z')
>>> s
set(['c', 'e', 'i', 'h', 'o', 'p', 's','y'])
>>> s -= set('pypi')
>>> s
set(['c', 'e', 'h', 'o', 's'])

只有可变集合能被修改。试图修改不可变集合会引发异常：

>>> t.add('z')
Traceback (most recent call last):
File "<stdin>", line 1, in?
AttributeError: 'frozenset' object has noattribute 'add'

四：集合类型操作符

1：标准类型操作符，适合所有的集合类型

成员关系(in, not in)：

>>> s = set('cheeseshop')
>>> t = frozenset('bookshop')
>>> 'k' in s
False
 
>>> 'k' in t
True
 
>>> 'c' not in t
True

集合等价/不等价

等价/不等价被用于在相同或不同的集合之间做比较。两个集合相等是指，对每个集合而言，当且仅当其中一个集合中的每个成员同时也是另一个集合中的成员。集合等价/不等价与集合的类型或集合成员的顺序无关，只与集合的元素有关。

>>> s == t
False
 
>>> s != t
True
 
>>> u = frozenset(s)
>>> s == u
True
 
>>> set('posh') == set('shop')
True

子集/超集

用比较操作符检查某集合是否是其他集合的超集或子集。“小于”符号( <, <= )用来判断子集，“大于”符号( >, >= )用来判断超集。

>>> set('shop') <set('cheeseshop')
True
 
>>> set('bookshop') >=set('shop')
True

2：集合类型操作符，适合所有的集合类型

联合( | )

两个集合的联合是一个新集合，该集合中的每个元素都至少是其中一个集合的成员。联合符号有一个等价的方法：union().

>>> s | t
set(['c', 'b', 'e', 'h', 'k', 'o', 'p','s'])

交集( & )

两个集合的交集是一个新集合，该集合中的每个元素同时是两个集合中的成员，交集符号有一个等价的方法：intersection().

>>> s & t
set(['h', 's', 'o', 'p']

差补/相对补集( – )

两个集合（s和t）的差补或相对补集是指一个集合C，该集合中的元素，只属于集合s，而不属于集合t。差符号有一个等价的方法：difference().

>>> s - t
set(['c', 'e'])

对称差分( ^ )

两个集合(s和t)的对称差分是指另外一个集合C,该集合中的元素，只能是属于集合s 或者集合t的成员，不能同时属于两个集合。对称差分有一个等价的方法：symmetric_difference().

>>> s ^ t
set(['k', 'b', 'e', 'c'])

混合集合类型操作

上面的示例中，左边的s是可变集合，而右边的t是一个不可变集合.使用集合操作运算符所产生的仍然是可变集合,但是如果左右操作数的顺序反过来，结果就不一样了。

        如果左右两个操作数的类型相同，则所产生的结果类型是相同的，但如果左右两个操作数的类型不相同，则所产生的结果类型与左操作数的类型相同。

还要注意，加号不是集合类型的运算符：

>>> t | s
frozenset(['c', 'b', 'e', 'h', 'k', 'o','p', 's'])
>>> t ^ s
frozenset(['c', 'b', 'e', 'k'])
>>> t - s
frozenset(['k', 'b'])
>>> v = s + t
Traceback (most recent call last):
File "<stdin>", line 1, in?
TypeError: unsupported operand type(s) for+: 'set' and 'set'
>>> v = s | t
>>> v
set(['c', 'b', 'e', 'h', 'k', 'o', 'p','s'])
>>> len(v)
8
>>> s < v
True

3 集合类型操作符，仅适用于可变集合

(Union)Update ( |= )

这个更新方法从已存在的集合中添加(可能多个)成员，此方法和update()等价.

>>> s = set('cheeseshop')
>>> s |= set('pypi')
>>> s
set(['c', 'e', 'i', 'h', 'o', 'p', 's','y'])

保留/交集更新( &= )

保留(或交集更新)操作保留与其他集合的共有成员。此方法和intersection_update()等价.

>>> s = set(u)
>>> s &= set('shop')
>>> s
set(['h', 's', 'o', 'p'])

差更新 ( -= )

对集合s和t 进行差更新操作s-=t，差更新操作是集合s去除掉集合t中元素。此方法和difference_update()等价.

>>> s = set(u)
>>> s -= set('shop')
>>> s
set(['c', 'e'])

对称差分更新( ^= )

对集合s和t 进行对称差分更新操作(s^=t),对称差分更新操作会返回一个集合，该集合中的成员仅是原集合s 或仅是另一集合t 中的成员。此方法和symmetric_difference_update()等价.

>>> s = set(u)
>>> t = frozenset('bookshop')
>>> s ^= t
>>> s
set(['c', 'b', 'e', 'k'])

五：集合类型内建方法

1：适于所有集合的方法

已看到很多和内建方法等价的操作符，如下表：

方法名称	操作
s.issubset(t)	如果s是t的子集，则返回True,否则返回False
s.issuperset(t)	如果t是s的超集，则返回True,否则返回False
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()	返回一个新集合，它是集合s的浅复制

内建方法copy()没有等价的操作符。copy()方法比用像set(),frozenset(),这样的工厂方法复制对象的副本要快。

2：仅适用于可变集合的方法

方法名	操作
s.update(t)	用t中的元素修改s, s现在包含s或t的成员
s.intersection_update(t)	s中的成员是共同属于s和t的元素。
s.difference_update(t)	s中的成员是属于s但不包含在t中的元素
s.symmetric_difference_update(t)	s中的成员更新为那些包含在s或t中，但不是s和t共有的元素
s.add(obj)	在集合s中添加对象obj
s.remove(obj)	从集合s中删除对象obj；如果obj不是集合s中的元素，将引发KeyError错误
s.discard(obj)	如果obj是集合s中的元素，从集合s中删除对象obj；
s.pop()	删除集合s中的任意一个对象，并返回它
s.clear()	删除集合s中的所有元素

新的方法有 add(), remove(), discard(), pop(), clear(). 这些接受对象的方法，参数必须是可哈希的。

3：操作符和内建方法比较

很多内建的方法几乎和操作符等价。我们说"几乎等价"，意思是它们间是有一个重要区别：当用操作符时，操作符两边的操作数必须是集合。 在使用内建方法时，对象也可以是迭代类型的。

        4：总结

所有集合类型

len(s)		集合基数: 集合s中元素的个数
set([obj])		可变集合工厂函数：obj 必须是支持迭代的，由obj 中的元素创建集合，否则创建一个空集合。
frozenset([obj])		不可变集合工厂函数：执行方式和set()方法相同，但它返回的是不可变集合
	obj in s	成员测试：obj 是s 中的一个元素吗?
	obj not in s	非成员测试：obj 不是s 中的一个元素吗?
	s == t	等价测试: 测试s 和t 是否具有相同的元素?
	s != t	不等价测试: 与==相反
s.issubset(t)	s < t	(严格意义上)子集测试; s != t 而且s 中 所 有的元素都是t 的成员
	s <= t	子集测试(允许不严格意义上的子集): s 中所有的元素都是t 的成员
s.issuperset(t)	s > t	(严格意义上)超集测试: s != t 而且t 中所有的元素都是s 的成员
	s >= t	超集测试(允许不严格意义上的超集)：t中所有的元素都是s的成员
s.union(t)	s | t	合并操作：s或t中的元素（返回新集合）
s.intersection(t)	s & t	交集操作：s和t中的元素（返回新集合）
s.difference(t)	s - t	差分操作: s 中的元素，而不是t 中的元素（返回新集合）
s.symmetric_difference(t)	s ^ t	对称差分操作：s 或t 中的元素，但不是s和t 共有的元素（返回新集合）
s.copy()		复制操作:返回s的(浅复制)副本

仅用于可变集合

s.update(t)	s |= t	(Union) 修改操作: 将t中的成员添加到s
s.intersection_update(t)	s &= t	交集修改操作: s 中仅包括s 和t 中共有的成员
s.difference_update(t)	s -= t	差修改操作: s 中包括仅属于s 但不属于t 的成员
s.symmetric_difference_update(t)	s ^= t	对称差分修改操作: s 中包括仅属于s 或仅属于t 的成员
s.add(obj)		加操作: 将obj 添加到s
s.remove(obj)		删除操作: 将obj 从s 中删除；如果s 中不存在obj,将引发KeyError
s.discard(obj)		丢弃操作： remove()的友好版本，如果s中存在obj,从s中删除它
s.pop()		Pop 操作: 移除并返回s中的任意一个元素
s.clear()		清除操作: 移除s 中的所有元素