Python 學習筆記（九）Python元組和字典（三）

字典常用方法 copy() 返回一個字典的淺複製示例：淺拷貝d.copy() 深拷貝引入import copy copy.deepcopy() clear() 刪除字典內所有元素 clear是清除字典中的元素，不是把這個字典刪除，刪除字典需要用del 清空字典也可用e={} get() 返回指定 ...

字典常用方法

copy() 返回一個字典的淺複製

示例：淺拷貝d.copy()

　　　深拷貝引入import copy copy.deepcopy()

 1 >>> help(dict.copy)  #help()查看dict.copy的詳細內容
 2 Help on method_descriptor:
 3 
 4 copy(...)
 5     D.copy() -> a shallow copy of D  #字典d的淺拷貝
 6 
 7 >>> d ={"name":"python","web":"www.baidu.com"}
 8 >>> e =d
 9 >>> e
10 {'web': 'www.baidu.com', 'name': 'python'}
11 >>> d
12 {'web': 'www.baidu.com', 'name': 'python'}
13 >>> id(e)
14 49259112L
15 >>> id(d)   #可以看出e和d在記憶體中地址相同，e和d引用的是同一個對象
16 49259112L
17 >>> f=d.copy() #字典d的淺複製   
18 >>> f
19 {'web': 'www.baidu.com', 'name': 'python'}
20 >>> id(f)  #可以看出f與上面的e和d的記憶體地址不同，f創建了新的字典對象
21 13708552L
22 >>> d["lang"]="python"  #向字典d中添加一個對象，d中發生了變化，字典f並沒有收到影響，說明字典f是一個新的字典對象，d 和f 是兩個不同的對象
23 >>> d
24 {'lang': 'python', 'web': 'www.baidu.com', 'name': 'python'}
25 >>> f    
26 {'web': 'www.baidu.com', 'name': 'python'}
27 >>> d={"name":"zhangsan","enjoy":["python","tea","book"]}  #新建一個字典
28 >>> e =d.copy()   #對字典進行copy
29 >>> id(d),id(e)　　#看出他倆的記憶體地址不同，是兩個不同的對象
30 (13708280L, 13719208L)
31 >>> d["enjoy"]   #從字典d中取出enjoy所對應的列表的值
32 ['python', 'tea', 'book']
33 >>> d["enjoy"].remove("book") #將字典d中key為enjoy，值為book的元素移除
34 >>> d     #d 中的book已經被移除
35 {'enjoy': ['python', 'tea'], 'name': 'zhangsan'}
36 >>> e    #e中的book也被移除了
37 {'enjoy': ['python', 'tea'], 'name': 'zhangsan'}
38 >>> id(d["enjoy"]) #查看d['enjoy']的記憶體地址 與e['enjoy']的記憶體地址相同，說明是同一對象，copy只進行了淺拷貝，並沒有對enjoy列表進行拷貝，只是引用
39 49135752L
40 >>> id(e["enjoy"])
41 49135752L
42 >>> import copy  #引入copy模塊進行 深拷貝
43 >>> d
44 {'enjoy': ['python', 'tea'], 'name': 'zhangsan'}
45 >>> z =copy.deepcopy(d) #深拷貝
46 >>> z
47 {'enjoy': ['python', 'tea'], 'name': 'zhangsan'}
48 >>> id(d),id(z)  #可看出d和z 是不同的兩個對象
49 (13708280L, 13720296L) 
50 >>> id(d['enjoy']),id(z['enjoy'])  #可看出d['enjoy']和z['enjopy'] 記憶體地址不同，是兩個不同對象
51 (49135752L, 50109128L)

clear() 刪除字典內所有元素

　　clear是清除字典中的元素，不是把這個字典刪除，

　　刪除字典需要用del

　　清空字典也可用e={}

 1 >>> help(dict.clear)
 2 Help on method_descriptor:
 3 
 4 clear(...)
 5     D.clear() -> None.  Remove all items from D. #刪除字典中的所有元素
 6 
 7 >>> z
 8 {'enjoy': ['python', 'tea'], 'name': 'zhangsan'}
 9 >>> z.clear() #清除字典z中的元素
10 >>> z   #字典中的元素為空，字典存在，沒有刪除字典
11 {}
12 >>> del z  #刪除字典可用del 
13 >>> e
14 {'enjoy': ['python', 'tea'], 'name': 'zhangsan'}
15 >>> e ={}  #清空字典中的元素可以使用e={}
16 >>> e
17 {}
18 >>>

get() 返回指定鍵的值，如果值不在字典中返回default值

 1 >>> help(dict.get)
 2 Help on method_descriptor:
 3 
 4 get(...)
 5     D.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None. 如果k存在於d中則返回key所對應的值,否則預設返回None
 6 
 7 >>> d = {"enjoy":["python","tea"],"name":"zhangsan"}
 8 >>> d
 9 {'enjoy': ['python', 'tea'], 'name': 'zhangsan'}
10 >>> d.get("name") #返回指定鍵name，所對應的值
11 'zhangsan'
12 >>> d.get("enjoy") #返回指定鍵enjoy,所對應的值
13 ['python', 'tea']
14 >>> d["name"]  #這種方式也可以獲取，與d.get()的區別，就是如果字典中沒有key值，將會報錯keyError 如下示例
15 'zhangsan'
16 >>> d.get("teacher") #如果d.get("teacher")不存在則返回預設值none
17 >>> d.get("teacher","laoshi") #如果d.get("teacher")不存在，則返回後面的值
18 'laoshi'
19 >>> d["teacher"]
20 Traceback (most recent call last):
21   File "<stdin>", line 1, in <module>
22 KeyError: 'teacher'
23 >>>

setdefault() 和get()類似, 但如果鍵不存在於字典中，將會添加鍵並將值設為default

 1 >>> help(dict.setdefault)
 2 Help on method_descriptor:
 3 
 4 setdefault(...)
 5     D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D
 6 
 7 >>> d
 8 {'enjoy': ['python', 'tea'], 'name': 'zhangsan'}
 9 >>> d.setdefault("name")  #取出d中key為name的值
10 'zhangsan'
11 >>> d.setdefault("city","beijing") #city 不存在與字典中，則將city添加與字典中，city為key,beijing為value
12 'beijing'
13 >>> d
14 {'enjoy': ['python', 'tea'], 'city': 'beijing', 'name': 'zhangsan'}
15 >>> d.setdefault("teacher")  #teacher 不存在於字典中，則將teacher 作為key，value為none加入字典中
16 >>> d
17 {'enjoy': ['python', 'tea'], 'city': 'beijing', 'name': 'zhangsan', 'teacher': None}
18 >>>

items() 以列表返回可遍歷的(鍵, 值) 元組數組

iteritems() 與items()方法類似，返回的是一個迭代器

 1 >>> help(dict.items)
 2 Help on method_descriptor:
 3 
 4 items(...)
 5     D.items() -> list of D's (key, value) pairs, as 2-tuples #通過字典items方法得到的是含有字典key value元組為元素的列表
 6 
 7 >>> d
 8 {'enjoy': ['python', 'tea'], 'city': 'beijing', 'name': 'zhangsan', 'teacher': None}
 9 >>> d.items() #得到key、value元組為元素的列表
10 [('enjoy', ['python', 'tea']), ('city', 'beijing'), ('name', 'zhangsan'), ('teacher', None)]
11 >>> help(dict.iteritems)
12 Help on method_descriptor:
13 
14 iteritems(...)
15     D.iteritems() -> an iterator over the (key, value) items of D
16 
17 >>> d_iter=d.iteritems()
18 >>> type(d_iter)  
19 <type 'dictionary-itemiterator'>
20 >>> d_iter  
21 <dictionary-itemiterator object at 0x00000000013EDD68>
22 >>> list(d_iter) 
23 [('enjoy', ['python', 'tea']), ('city', 'beijing'), ('name', 'zhangsan'), ('teacher', None)]
24 >>>

keys() 以列表返回一個字典所有的鍵

iterkeys()

 1 >>> help(dict.keys)
 2 Help on method_descriptor:
 3 
 4 keys(...)
 5     D.keys() -> list of D's keys  #用這個方法，得到一個列表，這個列表是以字典key為元素來組成的
 6 
 7 >>> d
 8 {'enjoy': ['python', 'tea'], 'city': 'beijing', 'name': 'zhangsan', 'teacher': None}
 9 >>> d.keys() #得到字典中所有的key
10 ['enjoy', 'city', 'name', 'teacher']
11 >>> d.iterkeys() #迭代器
12 <dictionary-keyiterator object at 0x00000000013EDE58>
13 >>>

values() 以列表返回字典中的所有值

itervalues()

1 >>> d.values()  #得到字典value的列表
2 [['python', 'tea'], 'beijing', 'zhangsan', None]
3 >>> d.itervalues() #迭代器
4 <dictionary-valueiterator object at 0x00000000013EDE58>
5 >>>

pop() 刪除字典給定鍵 key 所對應的值，返回值為被刪除的值。key值必須給出。否則，返回default值。

 1 >>> help(dict.pop)
 2 Help on method_descriptor:
 3 #參數至少有一個key,相應著會返回一個字典中key所對應的value.
　　#如果字典中沒有key,就返回第二個參數d的值，但如果d的值不寫，就會報錯
 4 pop(...)
 5     D.pop(k[,d]) -> v, remove specified key and return the corresponding value.  
 6     If key is not found, d is returned if given, otherwise KeyError is raised
 7 
 8 >>> d
 9 {'enjoy': ['python', 'tea'], 'city': 'beijing', 'name': 'zhangsan', 'teacher': None}
10 >>> d.pop("enjoy")#刪除enjoy鍵值對，返回的是enjoy對應的value值
11 ['python', 'tea']
12 >>> d
13 {'city': 'beijing', 'name': 'zhangsan', 'teacher': None}
14 >>> d.pop("enjoy","python") #在字典d中已經沒有enjoy這個鍵值對，返回第二個參數python
15 'python'
16 >>>

popitem() 隨機返回並刪除字典中的一對鍵和值。

 1 >>> help(dict.popitem)
 2 Help on method_descriptor:
 3 
 4 popitem(...)
 5     D.popitem() -> (k, v), remove and return some (key, value) pair as a
 6     2-tuple; but raise KeyError if D is empty.
 7 
 8 >>> d
 9 {'city': 'beijing', 'name': 'zhangsan', 'teacher': None}
10 >>> d.popitem()   #返回刪除的鍵值對，每次只能刪除一個，且是隨機刪除一個鍵值對，如果已經沒有鍵值對了，再去刪除就會報錯
11 ('city', 'beijing')
12 >>> d.popitem()
13 ('name', 'zhangsan')
14 >>> d.popitem()
15 ('teacher', None)
16 >>> d.popitem()
17 Traceback (most recent call last):
18   File "<stdin>", line 1, in <module>
19 KeyError: 'popitem(): dictionary is empty'
20 >>>

update () 把字典dict2的鍵/值對更新到dict里

1.返回值是none

2.以字典或可迭代對象為參數

3.如果參數有keys方法，就會迴圈E中的k,實現D[k]=E[kj]

 1 >>> help(dict.update)
 2 Help on method_descriptor:
 3 
 4 update(...)
 5     D.update([E, ]**F) -> None.  Update D from dict/iterable E and F.
 6     If E present and has a .keys() method, does:     for k in E: D[k] = E[k]
 7     If E present and lacks .keys() method, does:     for (k, v) in E: D[k] = v
 8     In either case, this is followed by: for k in F: D[k] = F[k]
 9 
10 >>> d1={"lang":"python"}
11 >>> d2={"name":"zhangsan"}
12 >>> d1.update(d2)
13 >>> d1
14 {'lang': 'python', 'name': 'zhangsan'}
15 >>> d2
16 {'name': 'zhangsan'}
17 >>> d2.update([("city","beijing"),("web","java"),("site","baidu.com")])
18 >>> d2
19 {'site': 'baidu.com', 'city': 'beijing', 'name': 'zhangsan', 'web': 'java'}
20 >>>

has_key() 如果鍵在字典dict里返回true，否則返回false

 1 >>> help(dict.has_key)
 2 Help on method_descriptor:
 3 
 4 has_key(...)
 5     D.has_key(k) -> True if D has a key k, else False
 6 
 7 >>> d2.has_key("city") #判斷key是否存在
 8 True
 9 >>> "city" in d2
10 True
11 >>>