Python回顾与整理5：映像和集合类型
0.说明python
依然是按照前面介绍的几种序列类型的思路来总结字映像类型和集合类型，即先作一个介绍，再讨论可用操做符、工厂函数、内建函数和方法。
算法
1.映射类型：字典bash
映射类型被称作哈希表，而Python中的字典对象就是哈希类型，即它是按照这样的方式来存储数据：（哈希表的算法）是获取键，对键执行一个叫作哈希函数的操做，并根据计算的结果，选择在数据结构的某个地址中来存储对象的值。任何一个值存储的地址取决于它的键，正由于这种随意性，哈希表中的值是没有顺序的，因此Python中的字典对象中的元素也是无序的。
数据结构
下面是字典的基本操做：
python2.7
（1）建立字典和给字典赋值ssh
主要的方法以下：
ide
直接建立赋值：可总体赋值，也能够逐一添加键值对函数
工厂函数dict()性能
>>> fdict = dict((['xpleaf', 'boy'], ['cl', 'girl']))
>>> fdict
{'xpleaf': 'boy', 'cl': 'girl'}
内建函数fromkeys()：建立默认字典，字典中元素具备相同的值（若是没有给出，默认为None）
测试
>>> fdict = {}.fromkeys(('xpleaf', 'cl'), 'lovings')
>>> fdict
{'xpleaf': 'lovings', 'cl': 'lovings'}
>>> edict = {}.fromkeys(('xpleaf', 'cl'))
>>> edict
{'xpleaf': None, 'cl': None}
（2）访问字典中的值
循环字典的键
>>> fdict = {'xpleaf': 'boy', 'cl': 'girl'}
>>> for key in fdict.keys():
... print key, fdict[key]
...
xpleaf boy
cl girl
使用迭代器访问类序列对象
>>> fdict = {'xpleaf': 'boy', 'cl': 'girl'}
>>> for key in fdict:
... print key, fdict[key]
...
xpleaf boy
cl girl
先判断键值是否存在再访问
>>> fdict = {'xpleaf': 'boy', 'cl': 'girl'}
>>> fdict.has_key('xpleaf')
True
>>> 'xpleaf' in fdict
True
>>> 'clyyh' in fdict
False
（3）更新字典
能够更新已有的键值对或添加新的键值对：
>>> fdict = {'host': 'xpleaf', 'port': 80}
>>> fdict['port'] = 3389
>>> fdict['ip'] = '121.42.147.131'
>>> print 'host: %(host)s, port: %(port)s, ip: %(ip)s' % fdict
host: xpleaf, port: 3389, ip: 121.42.147.131
（4）删除字典元素和字典
>>> fdict = {'host': 'xpleaf', 'port': 80, 'ip': '121.42.147.131'}
>>> del fdict['port'] #删除一个键值对
>>> fdict.clear() #删除字典中全部的键值对
>>> del fdict #删除整个字典
2.映射类型操做符
除了不支持拼接和重复，字典能够和全部的标准类型操做符一块儿工做。
（1）标准类型操做符
在《Python回顾与整理2：Python对象》中已经有介绍过标准类型操做符，它们对字典类型也是适合的，主要是：>、<、==和and等，以下：
>>> dict1 = {'abc': 123}
>>> dict2 = {'abc': 456}
>>> dict1 < dict2
True
>>> dict1 == dict2
False
（2）映射类型操做符
字典的键查找操做符（[]）
对序列类型来讲，用索引作惟一参数或下标以获取一个序列的值，可是对字典来讲，是用键查询，键是参数，而不是索引。经过`[]`操做符，能够在字典中查找元素，也能够为某个元素赋值。
键成员关系操做（in、not in）
固然也能够用has_key()。
3.映射类型的内建函数和工厂函数
（1）标准类型函数type()、str()、cmp()
这里不介绍cmp()，由于字典的比较算法比较复杂，并且不是很常常用，其它两个以下：
>>> d = {'name': 'xpleaf', 'age': 21}
>>> str(d)
"{'age': 21, 'name': 'xpleaf'}"
>>> unicode(d)
u"{'age': 21, 'name': 'xpleaf'}"
>>> type(d)
<type 'dict'>
（2）映射类型相关的函数
dict()
若是参数是容器类型而且是可迭代的，那么可抚今追昔的元素必须成对出现，从而生成一个字典：
>>> dict(zip(('x', 'y'), (1, 2)))
{'y': 2, 'x': 1}
>>> dict([['x', 1], ['y', 2]])
{'y': 2, 'x': 1}
>>> [('xy'[i-1], i) for i in range(1, 3)]
[('x', 1), ('y', 2)]
>>> dict([('xy'[i-1], i) for i in range(1, 3)])
{'y': 2, 'x': 1}
若是参数也是一个映射类型，好比一个字典对象，则会生成一个浅拷贝，但建议使用copy()方法：
>>> d = {'name': 'xpleaf', 'age': 21}
>>> d2 = dict(d)
>>> d2
{'age': 21, 'name': 'xpleaf'}
>>> id(d), id(d2)
(139762050623200, 139762085625480)
>>> [(id(x), id(d[x])) for x in d]
[(139762085618632, 23490424), (139762086747760, 139762085603104)]
>>> [(id(x), id(d[x])) for x in d2]
[(139762085618632, 23490424), (139762086747760, 139762085603104)]
>>>
>>> d3 = d2.copy()
>>> d3
{'age': 21, 'name': 'xpleaf'}
固然dict()还能够接受关键字参数：
>>> dict(x=1, y=2)
{'y': 2, 'x': 1}
len()：返回字典键值对的个数
>>> d = {'name': 'xpleaf', 'age': 21}
>>> len(d)
2
hash()：不是为字典设计的方法，可是能够判断某个对象是否能够做为一个字典的键
>>> hash('xpleaf')
-166083108737309362
>>> hash([])
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'
另外，即便那个对象的数据类型不一样，但只要它们的值相同，所得哈希值也是同样的：
>>> hash('xpleaf')
-166083108737309362
>>> hash(u'xpleaf')
-166083108737309362
4.映射类型内建方法
常见的内建方法以下：
dict.clear()：删除字典中的全部元素
>>> d = {'name': 'xpleaf', 'age': 21, 'loving': 'cl'}
>>> d
{'age': 21, 'name': 'xpleaf', 'loving': 'cl'}
>>> d.clear()
>>> d
{}
dict.copy()：返回字典的一个浅拷贝
dict.fromkeys(seq, val=None)：建立并返回一个字典，以seq中的元素作该字典的键，val作该字典中全部键对的初始值（若是不提供些值，则默认为None）
>>> {}.fromkeys(('name', 'age', 'loving'), 'Not set')
{'age': 'Not set', 'name': 'Not set', 'loving': 'Not set'}
>>> {}.fromkeys(('name', 'age', 'loving'))
{'age': None, 'name': None, 'loving': None}
dict.get(key, default=None)：返回字典中key对应的value，若是字典中不存在此键，则返回default的值（参数default的默认值为None）
>>> d = {'name': 'xpleaf', 'age': 21, 'loving': 'cl'}
>>> d.get('name')
'xpleaf'
>>> d.get('clyyh')
>>> d.get('clyyh', 'Not found')
'Not found'
dict.has_keys()：判断键是否存在于字典中，但如今建议用成员操做符in和not in
dict.items()：返回一个包含字典中、键值对元组的列表
>>> d = {'name': 'xpleaf', 'age': 21, 'loving': 'cl'}
>>> d.items()
[('age', 21), ('name', 'xpleaf'), ('loving', 'cl')]
>>> sorted(d.items()) #排序输出
[('age', 21), ('loving', 'cl'), ('name', 'xpleaf')]
dict.keys()：返回一个包含字典中键的列表
>>> d = {'name': 'xpleaf', 'age': 21, 'loving': 'cl'}
>>> d.keys()
['age', 'name', 'loving']
>>> sorted(d.keys()) #排序输出
['age', 'loving', 'name']
>>> sort_keys = d.keys()
>>> sort_keys
['age', 'name', 'loving']
>>> sort_keys.sort() #调用列表的sort()方法
>>> sort_keys
['age', 'loving', 'name']
dict.values()：返回一个包含字典中全部值的列表
>>> d = {'name': 'xpleaf', 'age': 21, 'loving': 'cl'}
>>> d.values()
[21, 'xpleaf', 'cl']
dict.iter*()：方法iteritems()、iterkeys()、itervalues()与它们对应的非迭代方法同样，不一样的是它们返回一个迭代子，而不是一个列表
>>> d = {'name': 'xpleaf', 'age': 21, 'loving': 'cl'}
>>> iter_keys = d.iterkeys()
>>> iter_keys
<dictionary-keyiterator object at 0x7f1ce39a25d0>
>>> type(iter_keys)
<type 'dictionary-keyiterator'>
>>> for key in iter_keys:
... print key
...
age
name
loving
当字典很是大时，使用这三种方法就能够大大节省内存空间，由于这三种方法的非迭代子方法返回的数据是直接存储在内存当中的，而这三种方法返回的是一个迭代子，能够理解为一个函数，用于动态获取字典中的这些值。
dict.pop(key[, default])：和get()方法相似，若是字典中key键存在，删除并返回dict[key]；若是key键不存在，且没有给出default的值，则引起KeyError异常（这点与get()方法不一样）
>>> d = {'name': 'xpleaf', 'age': 21, 'loving': 'cl'}
>>> d.pop('loving')
'cl'
>>> d
{'age': 21, 'name': 'xpleaf'}
>>> d.pop('clyyh', 'Not found')
'Not found'
>>> d.pop('clyyh')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 'clyyh'
dict.popitem()：随机删除一对键值对并以元组的形式返回
>>> d = {'name': 'xpleaf', 'age': 21, 'loving': 'cl'}
>>> d.popitem()
('age', 21)
dict.setdefault(key, default=None)：检查字典中是否含有某键，若是这个键存在，则返回该键对应的值；若是不存在，则能够给这个键赋默认值并返回此值
>>> d = {'name': 'xpleaf', 'age': 21, 'loving': 'cl'}
>>> d.setdefault('name')
'xpleaf'
>>> d.setdefault('clyyh')
>>> d
{'age': 21, 'clyyh': None, 'name': 'xpleaf', 'loving': 'cl'}
>>> d.setdefault('love', 'Not set')
'Not set'
>>> d
{'love': 'Not set', 'age': 21, 'clyyh': None, 'name': 'xpleaf', 'loving': 'cl'}
dict.update(dict2)：将字典dict2的键值对添加到dict中，字典中原有的键若是与新添加的键重复，那么原来字典中该键所对应的值就会被更新覆盖
>>> d = {'name': 'xpleaf', 'age': 21, 'loving': 'cl'}
>>> d2 = {'name': 'yonghaoye', 'clyyh': 'forever'}
>>> d.update(d2)
>>> d
{'age': 21, 'clyyh': 'forever', 'name': 'yonghaoye', 'loving': 'cl'}
5.字典的键
字典中的值是没有任何限制的，能够是任意Python对象，可是字典中的键是有限制的。
（1）不容许一个键对应多个值
从字典的存储方式去理解，这也是很合理的，由于值的存储地址就是经过字典的键来生成的。当有键发生冲突（即字典键重复赋值）时，会取最后（最近）的赋值，而不会产生错误，这是由于若是对每个键值对赋值时都检查该键是否存在，会占用必定的内存，相比之下，直接把该键原来对应的值覆盖的性能会更好。
>>> d = {'name': 'xpleaf', 'name': 'clyyh'}
>>> d
{'name': 'clyyh'}
>>> d['name'] = 'xpleaf'
>>> d
{'name': 'xpleaf'}
（2）键必须是可哈希的
对于不可变对象，值相等，表示的键相同
>>> d = {u'name': 'xpleaf', 'name': 'xpleaf', 1: 'clyyh', 1.0: 'clyyh'}
>>> d
{1: 'clyyh', u'name': 'xpleaf'}
有一些可变对象是可哈希的，如定义了__hash__()特殊方法的类
由于__hash__()方法返回一个整型，因此仍然是用不可变的值来作字典的键。
为何键是可哈希的
解释器调用哈希函数，根据字典中的值来计算存储数据的位置。若是键是可变对象，那么它的值可改变。当键发生变化时，哈希函数会映像到不一样的地址来存储数据。若是这样的状况发生，哈希函数就不可能可靠地存储或获取相关的数据。选择可哈希的键的缘由就是由于它们的值不能改变。
6.集合类型
在数学上，集合由不一样的元素组成，Python把这个概念引入到集合类型对象中。
在Python集合中，集合对象的成员（集合元素）是一组无序排列的可哈希的值，这也意味着集合的元素是不可变对象，所以均可以做为字典的键。而Python中的集合又能够分为两种：
可变集合set：能够添加和删除元素，是一个不可哈希的集合对象，所以不能够做为字典中的键或其余集合中的元素
>>> set_a = set('xpleaf')
>>> set_a
set(['a', 'e', 'f', 'l', 'p', 'x']) #无序排列
>>> hash(set_a) #不可哈希
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'set'
>>> set_a.add('clyyh') #添加元素
>>> set_a
set(['a', 'e', 'f', 'l', 'p', 'x', 'clyyh'])
>>> set_a.remove('clyyh') #删除元素
>>> set_a
set(['a', 'e', 'f', 'l', 'p', 'x'])
>>> set_a.add(set('clyyh')) #set集合自己不能够做为集合中的元素，由于集合中的元素必须是可哈希的
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'set'
不可变集合frozenset：不能够添加和删除元素，是一个可哈希的集合对象，所以能够做为字典中的键或是做为集合中的一个成员
>>> frozenset_b = frozenset('xpleaf')
>>> frozenset_b
frozenset(['a', 'e', 'f', 'l', 'p', 'x'])
>>> hash(frozenset_b)
6226730480975949720
>>> dir(frozenset_b) #没有添加和删除元素的方法
['__and__', '__class__', '__cmp__', '__contains__', '__delattr__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__or__', '__rand__', '__reduce__', '__reduce_ex__', '__repr__', '__ror__', '__rsub__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__xor__', 'copy', 'difference', 'intersection', 'isdisjoint', 'issubset', 'issuperset', 'symmetric_difference', 'union']
>>> set_a.add(frozenset_b) #frozenset集合能够做为集合中的元素
>>> set_a
set(['a', 'e', 'f', 'l', 'p', frozenset(['a', 'e', 'f', 'l', 'p', 'x']), 'x'])
但须要注意的是，由于集合自己是无序的，不能够为集合建立索引或执行切片操做，也没有键可用来获取集合中的元素：
>>> set_a = set('xpleaf')
>>> set_a
set(['a', 'e', 'f', 'l', 'p', 'x'])
>>> set_a[0]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'set' object does not support indexing
>>> set_a['a']
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'set' object has no attribute '__getitem__'
下面是数学集合操做符与Python集合操做符的对比说明：
| 集合操做符和关系符号 |
||
| 数学符号 | Python符号 | 说明 |
| ∈ | in | 是……的成员 |
| not in | 不是……的成员 | |
| = | == | 等于 |
| ≠ | != | 不等于 |
| < | 是……的真子集 | |
| <= | 是……的子集 | |
| > | 是……的真超集 | |
| >= | 是……的超集 | |
| ∩ | & | 交集 |
| ∪ | | | 并集 |
| -或\ | - | 差集或相对补集 |
| Δ | ^ | 对称差分 |
下面是集合的基本操做：
建立集合类型和给集合赋值
与列表和字典不一样，集合只能经过工厂函数set()或frozenset()来建立：
>>> a = set('xpleaf')
>>> b = frozenset('xpleaf')
>>> type(a)
<type 'set'>
>>> type(b)
<type 'frozenset'>
访问集合中的值
能够经过遍历或检查某项元素中否是一个集合的成员来实现：
>>> s = set('xpleaf')
>>> 'x' in s
True
>>> for i in s:
... print i,
...
a e f l p x
更新集合
对于可变集合set，可使用集合的内建方法add()、remove()、update()和操做符`-`等来更新集合：
>>> s = set('xpleaf')
>>> s
set(['a', 'e', 'f', 'l', 'p', 'x'])
>>> s.add('clyyh')
>>> s
set(['a', 'e', 'f', 'l', 'p', 'x', 'clyyh'])
>>>
>>> s.remove('clyyh')
>>> s
set(['a', 'e', 'f', 'l', 'p', 'x'])
>>>
>>> s.update('cl') #注意update()是先将'cl'变为一个集合再合并到原来集合中，这与add()方法不一样
>>> s
set(['a', 'c', 'e', 'f', 'l', 'p', 'x'])
>>>
>>> s -= set('xpleaf')
>>> s
set(['c'])
删除集合中的成员和集合自己
删除集合中的成员只针对于可变集合，上面已有说起，而对于集合自己，能够直接使用del来删除。
7.集合类型操做符
（1）标准类型操做符（适用于全部集合类型）
成员关系（in、not in）
>>> s = set('xpleaf')
>>> 'x' in s
True
>>> 'c' in s
False
集合等价/不等价（==、!=）
能够认为是数学中的集合相等与不相等，两种集合之间也能够比较：
>>> set('xpleaf') == frozenset('xpleaf')
True
>>> set('xpleaf') == frozenset('leaf')
False
>>> set('xpleaf') != frozenset('leaf')
True
子集/超集（<、<=、>、>=）
直接从元素是否相互包含的角度去理解便可：
>>> set('xpleaf') > frozenset('leaf')
True
>>> set('xpleaf') > frozenset('xpleaf')
False
>>> set('xpleaf') >= frozenset('xpleaf')
True
（2）集合类型操做符（适用于全部的集合类型）
并集（|）
>>> s = set('xpleaf')
>>> t = frozenset('leafhao')
>>> s | t
set(['a', 'e', 'f', 'h', 'l', 'o', 'p', 'x'])
固然也可使用集合的内建方法union()：
>>> s.union(t) set(['a', 'e', 'f', 'h', 'l', 'o', 'p', 'x']) >>> t.union(s) frozenset(['a', 'e', 'f', 'h', 'l', 'o', 'p', 'x'])
交集（&）
>>> s = set('xpleaf')
>>> t = frozenset('leafhao')
>>> s & t
set(['a', 'e', 'l', 'f'])
除了使用`&`操做符，也可使用集合的内建方法intersection()：
>>> s.intersection(t) set(['a', 'e', 'l', 'f'])
差集/相对补集（-）
>>> s = set('xpleaf')
>>> t = frozenset('leafhao')
>>> s - t
set(['p', 'x'])
>>> t - s
frozenset(['h', 'o'])
除了使用`-`操做符，也可使用集合的内建方法difference()：
>>> s.difference(t) set(['p', 'x']) >>> t.difference(s) frozenset(['h', 'o'])
对称差分（^）
两个集合（s和t）的对称差分是指另一个集合C，该集合中的元素只能是属于集合s或者集合t的成员，不能同时属于两个集合（相似于异或）：
>>> s = set('xpleaf')
>>> t = frozenset('leafhao')
>>> s ^ t
set(['p', 'x', 'h', 'o'])
除了使用`-`操做符，也可使用集合的内建方法symmetric_dirrerence()：
>>> s.symmetric_difference(t) set(['p', 'x', 'h', 'o'])
混合集合类型操做符
在上面的演示中，左边的s是可变集合，而右边的t是一个不可变集合，而所得的结果是可变集合，但若是把两个操做数的顺序反过来，结果就不同了：
>>> t | s frozenset(['a', 'e', 'f', 'h', 'l', 'o', 'p', 'x']) >>> t ^ s frozenset(['p', 'h', 'x', 'o']) >>> t - s frozenset(['h', 'o'])
即若是左右两个操做数的类型相同，则所产生的结果类型是相同的；若是不相同，则结果与左操做数的类型相同。但须要注意的是，加号`+`并非集合类型的操做符：
>>> s + set('leaf')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for +: 'set' and 'set'
（3）集合类型操做符（仅适用于可变集合）
其实就上面的四种操做符，只不过将其做为方法加进可变集合中或经过操做符实现，从而直接对可变集合自己产生影响：
并集更新（|=或update()）
>>> s = set('xpleaf')
>>> s2 = set('leafhao')
>>> s
set(['a', 'e', 'f', 'l', 'p', 'x'])
>>> s |= s2
>>> s
set(['a', 'e', 'f', 'h', 'l', 'o', 'p', 'x'])
保留更新（&=或intersection_update()）
>>> s = set('xpleaf')
>>> s2 = set('leafhao')
>>> s
set(['a', 'e', 'f', 'l', 'p', 'x'])
>>> s &= s2
>>> s
set(['a', 'e', 'l', 'f'])
差集更新（-=或difference_update()）
>>> s = set('xpleaf')
>>> s2 = set('leafhao')
>>> s
set(['a', 'e', 'f', 'l', 'p', 'x'])
>>> s -= s2
>>> s
set(['p', 'x'])
对称差分更新（^=或symmetric_diffenence_update()）
>>> s = set('xpleaf')
>>> s2 = set('leafhao')
>>> s
set(['a', 'e', 'f', 'l', 'p', 'x'])
>>> s ^= s2
>>> s
set(['h', 'o', 'p', 'x'])
8.内建函数
（1）标准类型函数
len()：返回一个集合中元素的个数
>>> s = set('xpleaf')
>>> t = frozenset('clyyh')
>>> len(s)
6
>>> len(t)
4
（2）集合类型工厂函数
主要是set()和frozenset()，分别用来生成可变和不可变集合，主要有下面两种方式：
不提供参数：默认生成空集合
>>> set() set([]) >>> frozenset() frozenset([])
提供参数：若是提供参数，则该参数必须是可迭代的，即一个序列，或迭代器，或支持迭代的一个对象，例如一个文件或一个字典
>>> set(['xpleaf', 'clyyh'])
set(['clyyh', 'xpleaf'])
>>>
>>> frozenset({'name': 'xpleaf', 'age': 21})
frozenset(['age', 'name'])
>>>
>>> f = open('numbers', 'w')
>>> for i in range(5):
... f.write('%d\n' % i)
...
>>> f.close()
>>> f = open('numbers', 'r')
>>> set(f)
set(['0\n', '3\n', '1\n', '4\n', '2\n'])
>>> f.close()
9.集合类型内建方法
（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()没有等价的操做符，和同名的字典内建方法dict.copy()同样，copy()方法比用像set()、frozenset()或dict()这样的工厂方法提制对象的副本要快，测试程序以下：
#!/usr/bin/env python
from time import time
def get_set_time():
start_time = time()
s = set('xpleaf')
end_time = time()
return end_time - start_time
def get_copy_time():
s = set('xpleaf')
start_time = time()
s2 = s.copy()
end_time = time()
return end_time - start_time
def get_result():
s_longer_than_c = 0
times = 100
for i in range(times):
if get_set_time() > get_copy_time():
s_longer_than_c += 1
if s_longer_than_c != 0:
return s_longer_than_c/float(times)
if __name__ == '__main__':
rate = get_result()
print 'Result***'
print 'The rate that set_method_time is longer than copy_method_time is:', rate
执行以下：
/usr/bin/python2.7 /home/xpleaf/PycharmProjects/Python_book/7/test_time.py Result*** The rate that set_method_time is longer than copy_method_time is: 0.51
固然，并不老是如此的，有时候会小于0.5，而且可能性也不小，这里只是做为简单的测试而已，实际上在使用时不用纠结太多。
（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() | s中的成员更新为那些包含中s或t中，但不是s和t共有的元素 |
| s.add(obj) | 在集合s中添加对象obj |
| s.remove(obj) | 从集合s中删除对象obj；若是obj不是集合s中的元素（obj not in s），将引起KeyError错误 |
| s.discard() | 若是obj是集合s中的元素，从集合s中删除对象obj |
| s.pop() | 删除集合s中的任意一个对象，并返回它 |
| s.clear() | 删除集合s中的全部元素 |
有了前面的基础以后，这些方法都比较简单，因此这里就不给出例子了，不过须要注意的是，须要接受参数的方法，其参数必须是可哈希的。
（3）操做符和内建方法比较
像上面看到的那样，不少内建的方法几乎和操做符等价。之因此说几乎等价而不是彻底等价，是由于：当用操做符时，操做符两边的操做数必须是集合，而在使用内建方法时，对象也能够是迭代类型的。缘由：采用易懂的set('abc').intersection('cbs')能够避免使用set('abc') `操做符` 'cbs'这样容易出错的构建方法。能够看下面的一个例子：
>>> s = set('xpleaf')
>>> s.intersection('leaf')
set(['a', 'e', 'l', 'f'])
>>> s & set('leaf')
set(['a', 'e', 'l', 'f'])
>>> s & 'leaf'
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for &: 'set' and 'str'
10.集合类型总结表
能够参考书上的总结表，很是详细。
11.相关模块
能够不用考虑，直接使用映射和集合类型便可。
- 1. Python映射类型、集合类型
- 2. 回顾—集合框架与泛型
- 3. Python回顾与整理10：模块
- 4. Chapter~7 映射和集合类型
- 5. C# 集合类型（经常使用集合类型整理）
- 6. Java回顾--集合
- 7. Python编程基础之六映射（dict）和集合类型（set）
- 8. python高级（三）—— 字典和集合（泛映射类型）
- 9. Python编程基础——映射（dict）和集合类型（set）
- 10. 集合类型 （python）
- 更多相关文章...
- • PHP 标量类型与返回值类型声明 - PHP 7 新特性
- • Rust 集合与字符串 - RUST 教程
- • Kotlin学习（二）基本类型
- • ☆技术问答集锦（13）Java Instrument原理
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. eclipse设置粘贴字符串自动转义
- 2. android客户端学习-启动模拟器异常Emulator: failed to initialize HAX: Invalid argument
- 3. android.view.InflateException: class com.jpardogo.listbuddies.lib.views.ListBuddiesLayout问题
- 4. MYSQL8.0数据库恢复 MYSQL8.0ibd数据恢复 MYSQL8.0恢复数据库
- 5. 你本是一个肉体，是什么驱使你前行【1】
- 6. 2018.04.30
- 7. 2018.04.30
- 8. 你本是一个肉体，是什么驱使你前行【3】
- 9. 你本是一个肉体，是什么驱使你前行【2】
- 10. 【资讯】LocalBitcoins达到每周交易比特币的7年低点