Python學習筆記字典

1、字典介紹
字典(dictionary)是除列表意外python之中最靈活的內置數據結構類型。列表是有序的對象結合，字典是無序的對象集合。二者之間的區別在於：字典當中的元素是經過鍵來存取的，而不是經過偏移存取。
一、字典的主要屬性
*經過鍵而不是偏移量來讀取
字典有時稱爲關聯數組或者哈希表。它們經過鍵將一系列值聯繫起來，這樣就可使用鍵從字典中取出一項。若是列表同樣可使用索引操做從字典中獲取內容。
*任意對象的無序集合
與列表不一樣，保存在字典中的項並無特定的順序。實際上，Python將各項從左到右隨機排序，以便快速查找。鍵提供了字典中項的象徵性位置（而非物理性的）。
*可變，異構，任意嵌套
與列表類似，字典能夠在原處增加或是縮短（無需生成一份拷貝），能夠包含任何類型的對象，支持任意深度的嵌套，能夠包含列表和其餘字典等。
*屬於可變映射類型
經過給索引賦值，字典能夠在原處修改。但不支持用於字符串和列表中的序列操做。由於字典是無序集合，根據固定順序進行操做是行不通的（例如合併和分片操做）。字典是惟一內置的映射類型（鍵映射到值得對象）。
*對象引用表（哈希表）
若是說列表是支持位置讀取對象的引用數組，那麼字典就是支持鍵讀取無序對象的引用表。從本質上講，字典是做爲哈希表（支持快速檢索的數據結構）來實現的。一開始很小，並根據要求而增加。此外，Python採用最優化的哈希算法來尋找鍵，所以搜索是很快速的。和列表同樣字典存儲的是對象引用。
二、常見的字典操做
能夠查看庫手冊或者運行dir(dict)或者help(dict),類型名爲dict。當寫成常量表達式時，字典以一系列"鍵:值（key:value)」對形式寫出的，用逗號隔開，用大括號括起來。能夠和列表和元組嵌套
操做                        解釋
D1={}                        空字典
D={'one':1}                    增長數據
D1[key]='class'                    增長數據：已經存在就是修改，沒有存在就是增長數據
D2={'name':'diege','age':18}            兩項目字典
D3={'name':{'first':'diege','last':'wang'},'age':18} 嵌套
D2['name']                    以鍵進行索引計算
D3['name']['last']                字典嵌套字典的鍵索引
D['three'][0]                    字典嵌套列表的鍵索引
D['six'][1]                    字典嵌套元組的鍵索引
D2.has_key('name')                 方法：判斷字典是否有name鍵
D2.keys()                    方法：鍵列表
list(D)                        獲取D這個字典的的KEY的 MS按字典順序排序成一個列表
D2.values()                      方法：值列表
'name' in D2                    方法：成員測試：注意使用key來測試
D2.copy()                     方法：拷貝
D2.get(key,deault)                方法：默認 若是key存在就返回key的value,若是不存在就設置key的value爲default。可是沒有改變原對象的數據
D2.update(D1)                    方法：合併。D1合併到D2,D1沒有變化，D2變化。注意和字符串，列表好的合併操做」+「不一樣
D2.pop('age')                    方法：刪除 根據key刪除,並返回刪除的value
len(D2)                        方法：求長（存儲元素的數目)
D1[key]='class'                    方法：增長：已經存在的數據就是修改，沒有存在就是增長數據
D4=dict(name='diege',age=18)            其餘構造技術
D5=dict.fromkeys(['a','b'])                 其餘構造技術 dict.fromkeys 能夠從一個列表讀取字典的key 值默認爲空，可指定初始值.兩個參數一個是KEY列表，一個初始值
>>> D4
{'a': None, 'b': None}
>>> D5=dict.fromkeys(['a','b','c'],0)
>>> D5
{'a': 0, 'c': 0, 'b': 0}
D6=dict(zip(keyslist.valslist))             ？？？
>>> D={}    
>>> D={'one':1}
>>> D
{'one': 1}
列表不能經過這樣的方法來增長數據，列表只能經過append方法，列表之能經過L[1]='A'這樣的方法來修改已存在序列的數據。
2、實際應用中的字典
一、字典的基本操做
1）、建立字典的方法 和修改
所有數據一塊兒添加
>>> D={'name':'diege','age':18}
>>> D
{'age': 18, 'name': 'diege'}

>>> D={}
>>> D['name']='diege'
>>> D['age']=18        
>>> D
{'age': 18, 'name': 'diege'}
>>> D1['age']=19
>>> D1
{'age': 19, 'name': 'diege'}
一樣鍵不存在是新添加數據，鍵存在就是修改數據

>>> D1=dict(name='diege',age=18)
>>> D1
{'age': 18, 'name': 'diege'}
將數據按按key=value做爲參數傳遞給dict()
dict(mapping) -> new dictionary initialized from a mapping object's (key, value) pairs
>>> D=dict.fromkeys(['name','age'])  
>>> D
{'age': None, 'name': None}
建立只有key沒有value的字典。

>>> D=dict.fromkeys(['name','age'],0)  
>>> D
{'age': 0, 'name': 0}
2）、索引
>>> D['age']
18
3）、取長
>>> len(D)
2
4）、鍵存在判斷-參數使用key
>>> D.has_key('name')
True
5)、成員判斷 使用key
>>> 'age' in D
True
6）、字典的鍵查看 返回鍵的列表
>>> D.keys()        
['age', 'name']
7）、字典的值查看 返回值的列表
>>> D.values()
[18, 'diege']
8)、拷貝
D2.copy()    
二、原處修改字典
1）增長數據
>>> D['age']=18        
>>> D
{'age': 18, 'name': 'diege'}
>>> D1['age']=19
>>> D1
{'age': 19, 'name': 'diege'}
一樣鍵不存在是新添加數據，鍵存在就是修改數據

2）刪除數據
根據鍵刪除
pop方法是從字典中刪除一個鍵並返回它的值  
>>> D.pop('age')  
18
方法是從字典中刪除一個鍵並返回它的值  
>>> del D['age']
18
從字典前面一對K:V的方式刪除，並返回K,V合成的元組
>>> D3.popitem()
('age', 18)
清空字典全部數據
D1.clear()
3）合併數據
D2.update(D1)                    方法：合併。D1合併到D2,D1沒有變化，D2變化。注意和字符串，列表好的合併操做」+「不一樣
>>> D1
{'name': 'diege'}
>>> D2
{'class': 2, 'level': 2012}
>>> D2.update(D1)
>>> D1
{'name': 'diege'}
>>> D2
{'class': 2, 'name': 'diege', 'level': 2012}

三、其餘字典方法
字典方法提供不少工具，例如 字典keys,valuse和items方法分別返回字典的鍵列表,值列表和(key,value)對元組
key列表
>>> D2.keys()
['class', 'name', 'level']
value列表
>>> D2.values()    
[2, 'diege', 2012]
K,V元組的列表
>>> D2.items()      
[('class', 2), ('name', 'diege'), ('level', 2012)]
>>> D2.viewkeys()      
dict_keys(['class', 'name', 'level'])
>>> D2.viewvalues()    
dict_values([2, 'diege', 2012])
>>> D2.viewitems()      
dict_items([('class', 2), ('name', 'diege'), ('level', 2012)])

四、語言表
>>> table={'Python':'Guido',
... 'Perl':'Larry',
... 'Tcl':'John'}

for lang in table.keys():
...  print lang,'\t',table[lang]
...
Python  Guido
Tcl     John
Perl    Larry
由於字典並不是序列，沒法像字符串和列表那樣直接經過一個for語句迭代他們。但若是要遍歷字典的鍵列表很容易。調用字典的keys()方法，返回通過排序以後全部鍵的列表。再用for循環進行迭代。
實際上，Python也能然給你遍歷字典的鍵的列表，而並不用在多數for循環中調用keys方法.就職何字典D而言，寫成for key in D:和寫成完整的for key in D.keys()：效果是同樣的
>>> for key in table:
...  print key
...
Python
Tcl
Perl
>>> for key in table.keys():
...  print key
...
Python
Tcl
Perl
>>> for key in table.values():
...  print key                
...
Guido
John
Larry
3、字典用法注意事項
*序列運算無效。沒法有序合併和分片
*對新索引賦值會增長項。
*鍵不必定老是字符串。任何不可變對象均可以（也就是否是列表）
一、使用字典模擬靈活的列表
當使用列表的時，對在列表末尾外的偏移賦值是非法的。
>>> L=[]
>>> L[99]='diege'
Traceback (most recent call last):
 File "<stdin>", line 1, in <module>
IndexError: list assignment index out of range
雖然可使用重複預先分配足夠的大的列表（例如 [0]*100）。但也可使用字典來坐相似的事。這樣就不須要這樣的空間分配了。
使用整數鍵時，字典能夠效仿列表再偏移賦值時增加
>>> [0]*100>>> L=[0]*100      
>>> L[99]='diege
>>> D={}
>>> D[99]='diege'
>>> D[99]
'diege
這樣的不用未來可能會用到的會被賦值的全部位置都分配空間。這樣字典很像更具靈活性的列表。
二、字典用於稀疏數據結構
例如多維數組中只有少數位置上有存儲的值
>>> M={}
>>> M[(2,3,4)]=88
>>> M[(7,8,9)]=99  
>>> X=2;Y=3;Z=4
>>> M[(X,Y,Z)]
88
>>> M
{(2, 3, 4): 88, (7, 8, 9): 99}
這個數組中只有兩個位置(2,3,4),(7,8,9)有值，其餘位置都未空。鍵是元組，他們記錄非空元素的座標。咱們並非分配一個龐大而幾乎爲空的三維矩陣，而是使用一個簡單的兩個元素的字典。經過這一方式讀取空元素的時，會觸發鍵不存在的異常。由於這些元素實質上並無被存儲。
>>> M[(5,6,7)]    
Traceback (most recent call last):
 File "<stdin>", line 1, in <module>
KeyError: (5, 6, 7)
三、避免missing-key錯誤
讀取不存在的鍵的錯誤在稀疏矩陣中很常見。然而可能並不但願程序由於這一次錯誤而被關閉。這裏有三種方式可讓咱們填入默認值而不會出現這樣
的錯誤提示，
一、）使用if語句預先對鍵進行測試。
>>> if M.has_key((5,6,7)):
...  print M[(5,6,7)]
... else:
...  print 0
...
0
2)、使用try語句明確地捕獲並修復這一異常。
>>> try:
...  print M[(5,6,7)]
... except KeyError:
...  print 0
...
0
3）、使用get方法爲不存在的鍵提供一個默認值
>>> M.get((2,3,4),0)  
88
>>> M.get((5,6,7),0)
0
從編程的須要方面來講，get方法是三者中最簡捷的。
四、使用字典做爲「記錄」
通常說來，字典能夠取代搜索數據結構（由於用鍵進行索引是一種搜索操做），而且能夠表示多種結構化信息的類型。例如，字典是在程序範圍中多種描述某一項
屬性的方法之一。也就是說，它們能偶扮演其餘語言中的「記錄」和結構相同的角色。隨時間經過向新鍵賦值來填寫字典的列子
>>> rec={}
>>> rec['name']='diege'
>>> rec['age']=28        
>>> rec['job']='sa/db'
>>> print rec['name']
diege
特別是在嵌套的時候，Python的內建數據類型能夠很輕鬆地表達結構化信息。使用字典來捕獲對象的屬性，可是它是一次性寫好的，並且嵌套了一個列表和一個字典來表達結構化屬性的值。
>>> offer={'name':'diege','jobs':['sa','dba'],'web':'www.skylog.cn/~diege','home':{'state':'SH','zip':8088}}
當去讀嵌套對象的元素時，只要簡單地吧索引操做串起來就能夠了
>>> offer['name']
'diege'
>>> offer['jobs'][1]
'dba'
>>> offer['home']['state']
'SH
五、建立字典的其餘方法
1）
>>> {'name':'diege','age':45}
{'age': 45, 'name': 'diege'}
2）
>>> D={}
>>> D['name']='lily'
>>> D['age']=18        
>>> D
{'age': 18, 'name': 'lily'}
3）
>>> dict(name='kelly',age=19)    
{'age': 19, 'name': 'kelly'}
注意這裏name,age沒有 ’‘括起來，由於這裏是變量。
4)
>>> dict([('name','tom'),('age',23)])
{'age': 23, 'name': 'tom'}
這裏將每個數據(屬性），作爲元組放到一個列表裏傳遞給dict函數

4種方法的選擇技巧
*若是能夠事先拼除整個字典，那麼第一種是很方便的。
*若是須要一次動態地創建字典的一個字段，第二種比較合適
*第三種關鍵字形式所需的代碼比常量少，【可是鍵必須是都是字符串纔可行】
*若是須要在程序運行時把鍵和值逐步建成序列。第四中比較有用。
zip函數把程序運行動態得到的鍵和值列表合併在一塊兒（例如分析數據文件字段）
若是全部鍵的值都相同，可使用特殊形式對字典進行初始化。簡單傳入一個鍵列表，以及全部鍵的初始值（默認爲空）
>>> dict.fromkeys(['a','b','c'],0)
{'a': 0, 'c': 0, 'b': 0}