摘要：這種數據結構包含以下幾種常見的操作向關聯數組添加鍵值對從關聯數組內刪除鍵值對修改關聯數組內的鍵值對根據已知的鍵尋找值字典問題是設計一種能夠具備關聯數組特性的數據結構。

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

>>> mydict = {}
>>> mydict
{}
>>> type(mydict)

>>> 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)


或者這樣：

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

>>> 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)


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

Traceback (most recent call last):
  File "", line 1, in 
    dd={[1,2]:1}
TypeError: unhashable type: "list"

字典類型的對象是以鍵值對的形式存儲數據的，所以只要知道鍵就能得到值，這在本質上就是一種映射關系。

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

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

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

返回字典d中的鍵key的值

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

將值賦給字典d中的鍵key

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

刪除字典d中的鍵key值對

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

檢查字典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()實現的是深拷貝

>>> 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中的列表是同一個對象，但是作為字符串的那個鍵值對屬于不同的對象。

>>> 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的作用是將字典清空，得到的是空字典。del是將字典刪除，內存中就沒有它了。

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

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

Traceback (most recent call last):
  File "", line 1, in 
    x
NameError: name "x" is not defined
>>>

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

得到字典中的某個值

>>> 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 "", line 1, in 
    d["age"]
NameError: name "d" is not defined

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

dict.get()和dict[key]的區別在于：如果鍵不在字典中，前者返回None，后者拋出異常

>>> 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"}

>>> 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)

>>> list(dd_kv)
[("websit", "www.liuguoquan.com"), ("age", 40), ("name", "liu")]

>>> dd_iter=dd.iteritems()
>>> type(dd_iter)

>>> dd_iter

>>> 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"]

刪除字典鍵值對

>>> 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 "", line 1, in 
    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
{}

更新字典

>>> 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"}

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

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