Python基礎之(三)之字典

定義

Python中有一個叫作dictionary的物件型別，翻譯過來就是“字典”，用dict表示。

建立字典

建立空的字典

>>> mydict = {}
>>> mydict
{}
>>> type(mydict)
<type 'dict'>
>>> person={"name":"liu","sex":"male","age":10}
>>> person
{'age': 10, 'name': 'liu', 'sex': 'male'}

字典dict是以鍵值對的形式儲存資料。比如"name":"liu"前面的name叫作鍵（key），後面的liu是前面的鍵所對應的值（value）。在一個字典中，鍵是唯一的，不能重複。值則對應於鍵，值可以重複。

鍵值之間用冒號隔開，每一對鍵值之間用逗號隔開。

新增字典

>>> person
{'age': 10, 'name': 'liu', 'sex': 'male'}
>>> person["hobby"]="reading" #增加鍵值對的方法
>>> person
{'hobby': 'reading', 'age': 10, 'name': 'liu', 'sex': 'male'}

修改字典

>>> person["age"]=20
>>> person
{'hobby': 'reading', 'age': 20, 'name': 'liu', 'sex': 'male'}
>>> id(person)
49368784
>>> person["age"]=30
>>> person
{'hobby': 'reading', 'age': 30, 'name': 'liu', 'sex': 'male'}
>>> id(person)
49368784

結果可以看出，字典可以原地地修改，即它是可變的，並且不會建立新的物件。

利用元組建立字典

>>> name = (["first","Google"],["second","Yahoo"])
>>> website=dict(name)
>>> website
{'second': 'Yahoo', 'first': 'Google'}
>>> type(website)
<type 'dict'>

或者這樣：

>>> ad = dict(name="liu",age= 26)
>>> ad
{'age': 26, 'name': 'liu'}
>>> type(ad)
<type 'dict'>

使用fromkeys建立字典

>>> website={}.fromkeys(("third","forth"),("facebook","amazon"))
>>> website
{'forth': ('facebook', 'amazon'), 'third': ('facebook', 'amazon')}
>>> website={}.fromkeys(("third","forth"),"facebook")
>>> website
{'forth': 'facebook', 'third': 'facebook'}

特別注意的是，字典中的鍵必須是不可變物件，值可以是任意類的物件。

>>> dd = {(1,2):1}
>>> dd
{(1, 2): 1}
>>> type(dd)
<type 'dict'>

>>> dd={[1,2]:1}

Traceback (most recent call last):
  File "<pyshell#52>", line 1, in <module>
    dd={[1,2]:1}
TypeError: unhashable type: 'list'

訪問字典的值

字典型別的物件是以鍵值對的形式儲存資料的，所以只要知道鍵就能得到值，這在本質上就是一種對映關係。

>>> person
{'hobby': 'reading', 'age': 30, 'name': 'liu', 'sex': 'male'}
>>> person["age"]
30
>>> person["hobby"]
'reading'

基本操作

len(d)

返回字典d中鍵值對的數量

>>> city_code = {"beijing":"010","shanghai":"021","guangzhou":"020"}
>>> len(city_code)
3

d[key]

返回字典d中的鍵key的值

>>> city_code
{'beijing': '010', 'shanghai': '021', 'guangzhou': '020'}
>>> city_code["beijing"]
'010'

d[key] = value

將值賦給字典d中的鍵key

>>> city_code
{'beijing': '010', 'shanghai': '021', 'guangzhou': '020'}
>>> city_code["beijing"]="01110"
>>> city_code
{'beijing': '01110', 'shanghai': '021', 'guangzhou': '020'}

del d[key]

刪除字典d中的鍵key值對

>>> city_code
{'beijing': '01110', 'shanghai': '021', 'guangzhou': '020'}
>>> del city_code["beijing"]
>>> city_code
{'shanghai': '021', 'guangzhou': '020'}

key in d

檢查字典d中是否含有鍵為key的項

>>> city_code
{'shanghai': '021', 'guangzhou': '020'}
>>> "shanghai" in city_code
True
>>> "beijing" in city_code
False

字串格式化輸出

>>> city_code
{'shanghai': '021', 'guangzhou': '020'}
>>> "Shanghai is a wonderful city,its area code is %(shanghai)s" % city_code
'Shanghai is a wonderful city,its area code is 021'

相關概念

關聯陣列

在電腦科學中，關聯陣列又稱為對映（Map）、字典（Dictionary），是一個抽象的資料結構，它包含著類似於鍵值的有序對。這種資料結構包含以下幾種常見的操作：

• 向關聯陣列新增鍵值對

• 從關聯陣列內刪除鍵值對

• 修改關聯陣列內的鍵值對

• 根據已知的鍵尋找值

字典問題是設計一種能夠具備關聯陣列特性的資料結構。解決字典問題的常用方法是雜湊表，但有些情況也可以直接使用有地址的陣列、二叉樹，或者其他結構。

雜湊表

雜湊表（hash table，也叫雜湊表），是根據關鍵字而直接訪問在記憶體儲存位置的資料結構。即把鍵值通過一個函式的計算，對映到表中的一個位置來訪問記錄，加快了查詢速度。這個對映函式稱為雜湊函式，存放記錄的陣列稱為雜湊表。

字典的函式

拷貝

淺拷貝：Python在所執行的複製動作中，如果是基本型別的資料，就在記憶體中新建一個地址儲存，如果不是基本型別，就不會新建一個地址，而是用標籤引用原來的物件。copy()實現的是淺拷貝

深拷貝：無論是基本資料型別還是其他型別都會新建一個地址來儲存。deepcopy()實現的是深拷貝

copy()

>>> ad={"name":"liu","age":20}
>>> id(ad)
49368640
>>> cd= ad.copy()
>>> cd
{'age': 20, 'name': 'liu'}
>>> id(cd)  #與ad是不同的物件
49225776
>>> cd["age"]=40  #修改cd沒有對ad造成影響
>>> cd
{'age': 40, 'name': 'liu'}
>>> ad
{'age': 20, 'name': 'liu'}

>>> x={"name":"liu","lang":["python","java","c"]}
>>> y = x.copy()
>>> y
{'lang': ['python', 'java', 'c'], 'name': 'liu'}
>>> id(x)
49226496
>>> id(y)
49228800

##y是從x拷貝過來的，兩個在記憶體中是不同的物件

>>> y["lang"].remove("c")
>>> y
{'lang': ['python', 'java'], 'name': 'liu'}
>>> x
{'lang': ['python', 'java'], 'name': 'liu'}
>>> id(x)
49226496
>>> id(y)
49228800

y中刪除元素“c“後，x的鍵lang的值也發生了變化

>>> id(x["lang"])
49607424
>>> id(y["lang"])
49607424

x與y中的列表是同一個物件，但是作為字串的那個鍵值對屬於不同的物件。

deepcopy()

>>> x
{'lang': ['python', 'java'], 'name': 'liu'}
>>> import copy #匯入一個模組
>>> z = copy.deepcopy(x) #深拷貝
>>> z
{'lang': ['python', 'java'], 'name': 'liu'}
>>> id(x["lang"])
49607424
>>> id(z["lang"])
49607184

#此時x和z中的列表不屬於同個物件

>>>
>>> x["lang"].remove("java")
>>> x
{'lang': ['python'], 'name': 'liu'}
>>> z
{'lang': ['python', 'java'], 'name': 'liu'}

#此時，修改一個列表的值，就不會影響另外一個列表的值了。

clear

clear的作用是將字典清空，得到的是空字典。del是將字典刪除，記憶體中就沒有它了。

>>> x
{'lang': ['python'], 'name': 'liu'}
>>> x.clear()
>>> x
{}
>>> del a

>>> del x
>>> x  #x已刪除

Traceback (most recent call last):
  File "<pyshell#147>", line 1, in <module>
    x
NameError: name 'x' is not defined
>>>

如果要清空一個字典，還能夠使用x = {}這種方法，但這種方法的本質是將變數a的引用轉向了{}這個物件，那麼原來的物件呢？原來的物件稱為了斷了線的風箏，這樣的東西稱為在Python中稱為垃圾，而且Python能夠自動將這樣的垃圾回收。

get和setdefault

得到字典中的某個值

get

>>> z
{'lang': ['python', 'java'], 'name': 'liu'}
>>> z["lang"].remove("java")
>>> z
{'lang': ['python'], 'name': 'liu'}
>>> 
>>> z.get("name")
'liu'

>>> print z.get("age") #返回None
None
>>> d["age"]  #丟擲異常
Traceback (most recent call last):
  File "<pyshell#160>", line 1, in <module>
    d["age"]
NameError: name 'd' is not defined

>>> z.get("age",30) #如果age不存在，則返回預設值30
30

dict.get()和dict[key]的區別在於：如果鍵不在字典中，前者返回None，後者丟擲異常

setdefault

>>> z
{'lang': ['python'], 'name': 'liu'}
>>> z.setdefault("age",30)  #如果age不存在，則返回預設值30，同時將這對鍵值對新增到字典中
30
>>> z
{'lang': ['python'], 'age': 30, 'name': 'liu'}

>>> z.setdefault("web")
>>> z
{'lang': ['python'], 'web': None, 'age': 30, 'name': 'liu'}

items/iteritems,keys/iterkeys,values/itervalues

>>> dd = {"name":"liu","age":40,"websit":"www.liuguoquan.com"}
>>> dd_kv = dd.items()
>>> dd_kv
[('websit', 'www.liuguoquan.com'), ('age', 40), ('name', 'liu')]
>>> type(dd_kv)
<type 'list'>
>>> list(dd_kv)
[('websit', 'www.liuguoquan.com'), ('age', 40), ('name', 'liu')]

>>> dd_iter=dd.iteritems()
>>> type(dd_iter)
<type 'dictionary-itemiterator'>
>>> dd_iter
<dictionary-itemiterator object at 0x02F5F420>
>>> list(dd_iter)  #必須用list()迭代遍歷
[('websit', 'www.liuguoquan.com'), ('age', 40), ('name', 'liu')]

>>> dd
{'websit': 'www.liuguoquan.com', 'age': 40, 'name': 'liu'}
>>> dd.keys() #列出鍵的列表
['websit', 'age', 'name']

>>> dd.values() #列出值的列表
['www.liuguoquan.com', 40, 'liu']

pop和popitem

刪除字典鍵值對

>>> dd
{'websit': 'www.liuguoquan.com', 'age': 40, 'name': 'liu'}
>>> dd.pop("name") #刪除指定鍵
'liu'

>>> dd
{'websit': 'www.liuguoquan.com', 'age': 40}
>>> dd.pop() #引數不能省略

Traceback (most recent call last):
  File "<pyshell#198>", line 1, in <module>
    dd.pop()
TypeError: pop expected at least 1 arguments, got 0


>>> dd
{'websit': 'www.liuguoquan.com', 'age': 40}
>>> dd.popitem() #隨機刪除一個鍵值對
('websit', 'www.liuguoquan.com')

>>> dd
{'age': 40}
>>> dd.popitem()
('age', 40)

>>> dd
{}

update

更新字典

>>> d1={"name":"liu"}
>>> d2={"age":20}
>>> d1.update(d2) #將字典到d2新增到d1中，更新字典
>>> d1
{'age': 20, 'name': 'liu'}
>>> d2
{'age': 20}

>>> d2.update([("name","lee"),("lang","python")]) #更新字典
>>> d2
{'lang': 'python', 'age': 20, 'name': 'lee'}

has_key

判斷字典中是否存在某個鍵

>>> d2
{'lang': 'python', 'age': 20, 'name': 'lee'}
>>> d2.has_key("name")
True
>>> d2.has_key("web")
False