python-資料型別之字典

Python字典是另一種可變容器模型，且可儲存任意型別物件，如字串、數字、元組等其他容器模型。
一、建立字典
（一）字典的增刪改查
（1）字典的建立
key:(不可變型別)數字、字串、元組
value:任何型別

>>> dict1={}
>>> dict2={`name`: `earth`, `port`: 80}
>>> dic1,dict2
({}, {`name`: `earth`, `port`: 80})

如果鍵值是列表，會報錯

 >>>dict1[[1,2]]={"aa","bbb"}
 Traceback (most recent call last):
 File "<stdin>", line 1, in <module>
 TypeError: unhashable type: `list`

鍵為元組：

>>> dict1[1,2]={"sss","ggg"}
>>> dict1
{(1, 2): set([`ggg`, `sss`]), `name`: `aileen`, `sex`: u`u5973`}

用工廠的方法建立字典：

>>> fdict = dict(([`x`, 1], [`y`, 2]))
>>> fdict
{`y`: 2, `x`: 1}
>>> fdict=dict(a=3,b=4)            #這個比較常用
>>> fdict
{`a`: 3, `b`: 4}

內建方法 fromkeys() 來建立一個”預設”字典：
dict.fromkeys(seq[, value]))
seq — 字典鍵值列表。
value — 可選引數, 設定鍵序列（seq）的值。

>>> ddict = {}.fromkeys((`x`, `y`), -1)
>>> ddict
{`y`: -1, `x`: -1}
>>> edict = {}.fromkeys((`foo`, `bar`))
>>> edict
{`foo`: None, `bar`: None}

（2）訪問字典的值:字典是無序的所以不能用索引進行訪問

>>> dict2 = {`name`: `earth`, `port`: 80}
>>> for key in dict2.keys():
...     print "key=%s,value=%s"%(key,dict2[key])
key=name,value=earth
key=port,value=80

>>> for key,value in dict2.items():
...     print key,value
name earth
port 80

>>> for value in dict2.values():
...     print value
earth
80

想訪問該字典中的一個資料元素，而它在這個字典中沒有對應的鍵，將會產生一個錯誤：

>>> dict2["sever"]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: `sever`

字典的方法：has_key()和 in 以及 not in 操作符都是布林型別的。
對於前兩者而言，如果字典中有該鍵就返回真(True)，否則返回假(False)。

>>> "sever" in dict2    #dict2.has_key("server")
False
>>> "name" in dict2    #dict2.has_key("name")
True
>>> "earth" in dict2.values()
True

（3）字典的更新
通過以下幾種方式對一個字典做修改：新增一個新資料項或新元素(即：一個鍵-值對)；修改一個已存在的資料項；或刪除一個已存在的資料項

>>> dict2[`name`] = `venus`          #更新已有的條目
>>> dict2[`port`] = 6969            #更新已有的條目
>>> dict2[`arch`] = `sunos5`         #增加新條目
>>> print "host %(name)s is running on port %(port)d"%dict2
host venus is running on port 6969

注：（1）如果字典中該鍵已經存在，則字典中該鍵對應的值將被新值替代。
（2）上面的 print 語句展示了另一種在字典中使用字串格式符( %)的方法。用字典引數可以簡化 print 語句，因為這樣做你只須用到一次該字典的名字，而不用在每個元素出現的時候都用元組參數列示。

（4）刪除字典元素和字典

>>> del dict2["name"]   #刪除鍵為”name”的條目
>>> dict2.clear()       #刪除dict2中所有的條目
>>> del dict2          #刪除整個dict2字典
>>> dict2.pop("name")   #刪除並返回鍵為”name”的條目

（二）字典相關函式
（1）dict()-工廠方法
工廠函式被用來建立字典。如果不提供引數，會生成空字典

>>> dict(zip((`x`, `y`), (1, 2)))
{`y`: 2, `x`: 1}
>>> dict([[`x`, 1], [`y`, 2]])
{`y`: 2, `x`: 1}
>>> dict([(`xy`[i-1], i) for i in range(1,3)])
{`y`: 2, `x`: 1}

呼叫 dict()方法可以接受字典或關鍵字引數字典

>>> dict8=dict(x=1,y=2)
>>> dict8
{`y`: 2, `x`: 1}
>>> dict9=dict(**dict8)             #只作為了解 dict()方法的用途
>>> dict9
{`y`: 2, `x`: 1}

>>> dict9=dict8.copy()   #此方法效率更好
>>> dict9
{`y`: 2, `x`: 1}

注：copy:dict3、dict2記憶體不同，改變一個另外一個不變

>>> dict3=dict2.copy()
>>> dict3
{`1`: 1, `3`: 3, `2`: 2}
>>> dict3["1"]=4
>>> dict2
{`1`: 1, `3`: 3, `2`: 2}
>>> id(dict3)
4323369880
>>> id(dict2)
4323370160
>>> id(dict2)
4323370160

引用，修改了一個另一個也改了

>>> dict4=dict2
>>> id(dict4)
4323370160
>>> id(dict2)
4323370160

(2)len()
對字典呼叫 len()，它會返回所有元素(鍵-值對)的數目

>>> dict2 = {`name`: `earth`, `port`: 80}
>>> len(dict2)
2

(3)hash():
判斷某個物件是否可以做一個字典的鍵,如果非可雜湊型別作為引數傳遞給 hash()方法，會產生TypeError 錯誤.返回的是返回 obj 的雜湊值

>>> hash(3)
3
>>> hash([])
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unhashable type: `list`
>>> dict2[{}]="foo"
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unhashable type: `dict`

（4）update函式
可以用來將一個字典的內容新增到另外一個字典中，字典中原有的鍵如果與新新增的鍵重複，那麼重複鍵所對應的原有條目的值將被新鍵所對應的值所覆蓋。原來不存在的條目則被新增到字典中。

>>> dict2= {`host`:`earth`, `port`:80}
>>> dict3= {`host`:`venus`, `server`:`http`}
>>> dict2.update(dict3)
>>> dict2
{`host`: `venus`, `port`: 80, `server`: `http`}
>>> dict2.update({"ip":"192.168.1.1"})
>>> dict2
{`ip`: `192.168.1.1`, `host`: `venus`, `port`: 80, `server`: `http`}

(5)get()方法
get方法與鍵查詢(key-lookup)操作符( [ ] )相似，不同的是它允許你為不存在的
鍵提供預設值。如果該鍵不存在，也未給出它的預設值，則返回 None。此方法比採用鍵查詢(key-lookup)更靈活，因為你不必擔心因鍵不存在而引發異常。
dict的get方法：

>>> dict2
{`ip`: `192.168.1.1`, `host`: `venus`, `port`: 80, `server`: `http`}
>>> dict2.get("host")
`venus`
>>> dict2.get("XXX")
>>> type(dict2.get("XXX"))
<type `NoneType`>
>>> dict2.get("XXX","no such key")
`no such key`

（6）Setdefault
檢查字典中是否含有某鍵。 如果字典中這個鍵存在，你可以取到它的值。 如果所找的鍵在字典中不存在，你可以給這個鍵賦預設值並返回此值。

>>> myDict = {`host`: `earth`, `port`: 80}
>>> myDict.keys()
[`host`, `port`]
>>> myDict.items()
[(`host`, `earth`), (`port`, 80)]
>>> myDict.setdefault("port",8080)
80
>>> myDict.setdefault("pot","tcp")
`tcp`
>>> myDict.items()
[(`host`, `earth`), (`port`, 80), (`pot`, `tcp`)]

(7)Fromkeys(seq,value=None)
建立並返回一個新字典，以 seq 中的元素做該字典的鍵，val 做該字典中所有鍵對應的初始值(如果不提供此值，則預設為 None)

>>> {}.fromkeys(`xyz`)
{`y`: None, `x`: None, `z`: None}
>>> {}.fromkeys((`love`, `honor`), True)
{`love`: True, `honor`: True}

(8)Sorted()

dic = {`a`:31, `bc`:5, `c`:3, `asd`:4, `33`:56, `d`:0}
print sorted(dic.iteritems(), key=lambda d:d[0], reverse = False )

按照value　排序：

dic = {`a`:31, `bc`:5, `c`:3, `asd`:4, `33`:56, `d`:0}
print sorted(dic.iteritems(), key=lambda d:d[1], reverse = False )

可以用以下方法做

>>> d={3:13,2:12,1:21}
>>> sorted_key=sorted(d.keys())
>>> for i in sorted_key:
...     print "%s =%s " %(i,d[i]) 

(9)dict.iter()
方法 iteritems(), iterkeys(), itervalues()與它們對應的非迭代方法一樣，不同的是它們返回一個迭代器，而不是一個列表。

（10）dict.pop(key[, default]) 與popitem函式
方法 get()相似，如果字典中 key 鍵存在，刪除並返回 dict[key]，
如果 key 鍵不存在，且沒有給出 default 的值，引發 KeyError 異常。

>>> myDict
{`host`: `earth`, `port`: 80, `pot`: `tcp`}
>>> myDict.pop("host")               #pop
`earth`
>>> myDict.pop("hostt","none")
`none`
>>> myDict.pop("hostt")
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: `hostt`

>>> myDict.popitem()             #popitem
(`host`, `earth`)
>>> myDict.popitem()
(`port`, 80)
>>> myDict.popitem()
(`pot`, `tcp`)
>>> myDict.popitem()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: `popitem(): dictionary is empty`