Python回顧與整理5：映像和集合類型

時間  2020-08-05
標籤 python 回顧 整理 映像 集合 類型 欄目 Python 简体版
原文   原文鏈接

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.相關模塊


        能夠不用考慮，直接使用映射和集合類型便可。

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程