python的dict更新

A. python字典中幾個常用函數總結

1、get() 返回指定鍵的值，如果值不在字典中返回default值。
語法：dict.get(key,default=None)
參數：
key 字典中要查找的鍵。
default 如果指定鍵的值不存在時，返回該默認值值。
例：
dict={'Name':'alex','Age':21}
print("Name is:%s"% dict.get('Name')+"\n"+ "Age is:%d"% dict.get('Age'))
顯示結果為：
Name is:alex
Age is:21

2、update() 將一個字典中的值更新到另一個字典中。
語法：dict.update(dict2)
參數：
dict2 添加到指定字典dict里的字典。
例：
dict={'Name':'alex','Age':21}
dict2={'Sex':'female'}
dict.update(dict2)
print("Value is %s" % dict)
顯示結果為：
Value is {'Name': 'alex', 'Age': 21, 'Sex': 'female'}

B. Python中的幾種特殊數據類型小結

下面介紹了Python中的6種特殊數據類型：

1.list:列表

是一種有序的數據集合，在列表數據結構中的類型並不唯一

定義形式：L=['Micha',100,True]

輸出整個列表的時候顯示為['Micha',100,True]

輸出單個的數值則為：Micha

a.訪問，直接使用L[0]表示第一個元素或者使用L[-1]表示最後一個數據，以此類推，但是注意訪問不能越界（訪問的序號不能超過元素的總數）。

b.添加新元素：使用L.append(100)直接將100加入列表末尾，或者使用L.insert(0,'paul')將paul插入任意位置。

c.刪除元素：L.pop（）刪除最後一個元素，或者L.pop(2)刪除第2個位置的元素。

d.替換元素：直接賦值就可以了L[2]=100

2.tuple:元組

是一種有序的列表，但是其一旦創立完畢就不能夠更改，即不能插入，刪除裡面的元素，訪問的方式跟List結構一致。

a.t=（）其列印後輸出的形式是（）

若t中的數據為一個數字則需要在後面加逗號，以區分普通數字，如t=(1,)，列印出（1，）而非1，多元素的話則沒有這個要求。

b.可以在不變的tuple中加入可變的List如t=（『a』,'b',['A','B']）

3.dict:字典

d = {

'Adam': 95,

'Lisa': 85,

'Bart': 59

}

len()函數可以計算任意集合的大小

其中可以簡單地使用d[key]的形式來查找對應的value，這和list很像，不同之處是，list必須使用索引返回對應的元素，而dict使用key,當key不存在的時候，使用該key可能出現錯誤，因此：要避免KeyError發生，有兩個辦法：

一是先判斷一下key是否存在，用in操作符：

if'Paul' in d:

print d['Paul']

如果'Paul'不存在，if語句判斷為False，自然不會執行print d['Paul']，從而避免了錯誤。

二是使用dict本身提供的一個get方法，在Key不存在的時候，返回None：

>>>print d.get('Bart')

59

a.dict中的key不能重復，且dict中的存儲的對應值沒有順序，列印出的東西可能是無序的

b.dict的更新：使用d[『paul']=72求解

c.dict遍歷：

d = {'Adam': 95, 'Lisa': 85, 'Bart': 59 }

>>>for key in d:

...print key

遍歷只能獲得key的值，需要通過key值獲得對應的value

4.set：集合

無序但是所有元素唯一，不重復

a.定義：s = set(['A', 'B', 'C']),查看set的內容：

>>>print s

set(['A','C', 'B'])

可以用in來判斷是否存在於集合中

b.遍歷

s =set([('Adam', 95), ('Lisa', 85), ('Bart', 59)])

for xin s:

print x[0]+':',x[1]

c.添加元素到集合中

s.add(4)

d.刪除元素

s.remove(4)若該元素不在集合中將會報錯

5.Unicode編碼

Python在後來添加了對Unicode的支持，以Unicode表示的字元串用u'...'表示，比如：

printu'中文'

注意:不加u，中文就不能正常顯示中文。

a.轉義形式：u'中文 日文 韓文'

b.輸出多行：

u'''第一行

第二行'''

c.raw+多行的形式：

ur'''Python的Unicode字元串支持"中文",

"日文",

"韓文"等多種語言'''

如果中文字元串在Python環境下遇到UnicodeDecodeError，這是因為.py文件保存的格式有問題。可以在第一行添加註釋

# -*-coding: utf-8 -*-

目的是告訴Python解釋器，用UTF-8編碼讀取源代碼。然後用Notepad++另存為， 並選擇UTF-8格式保存。

6.raw的作用

如果一個字元串包含很多需要轉義的字元，對每一個字元都進行轉義會很麻煩。為了避免這種情況，我們可以在字元串前面加個前綴r，表示這是一個「raw」字元串，裡面的字元就不需要轉義了。例如：

r'(~_~)//'

但是r'...'表示法不能表示多行字元串，也不能表示包含'和"的字元串，如果要表示多行字元串。

C. Python中的dict怎麼用

python中的dict使用方法類似php的關聯數組，java的map。

#定義一個dict
m={}
或者
m=dict()

#添加元素
m['a']=1

#更新元素
m['a']=2

#刪除元素
delm['a']

更多的你可以參考官方文檔：

https://docs.python.org/2/library/stdtypes.html

5.8. Mapping Types — dict

如果解決了您的問題請採納！
如果未解決請繼續追問！

D. 萬字干貨，Python語法大合集，一篇文章帶你入門

這份資料非常純粹，只有Python的基礎語法，專門針對想要學習Python的小白。

Python中用#表示單行注釋，#之後的同行的內容都會被注釋掉。

使用三個連續的雙引號表示多行注釋，兩個多行注釋標識之間內容會被視作是注釋。

Python當中的數字定義和其他語言一樣：

我們分別使用+, -, *, /表示加減乘除四則運算符。

這里要注意的是，在Python2當中，10/3這個操作會得到3，而不是3.33333。因為除數和被除數都是整數，所以Python會自動執行整數的計算，幫我們把得到的商取整。如果是10.0 / 3，就會得到3.33333。目前Python2已經不再維護了，可以不用關心其中的細節。

但問題是Python是一個 弱類型 的語言，如果我們在一個函數當中得到兩個變數，是無法直接判斷它們的類型的。這就導致了同樣的計算符可能會得到不同的結果，這非常蛋疼。以至於程序員在運算除法的時候，往往都需要手工加上類型轉化符，將被除數轉成浮點數。

在Python3當中撥亂反正，修正了這個問題，即使是兩個整數相除，並且可以整除的情況下，得到的結果也一定是浮點數。

如果我們想要得到整數，我們可以這么操作：

兩個除號表示 取整除 ，Python會為我們保留去除余數的結果。

除了取整除操作之外還有取余數操作，數學上稱為取模，Python中用%表示。

Python中支持 乘方運算 ，我們可以不用調用額外的函數，而使用**符號來完成：

當運算比較復雜的時候，我們可以用括弧來強制改變運算順序。

Python中用首字母大寫的True和False表示真和假。

用and表示與操作，or表示或操作，not表示非操作。而不是C++或者是Java當中的&&, || 和！。

在Python底層， True和False其實是1和0 ，所以如果我們執行以下操作，是不會報錯的，但是在邏輯上毫無意義。

我們用==判斷相等的操作，可以看出來True==1， False == 0.

我們要小心Python當中的bool()這個函數，它並不是轉成bool類型的意思。如果我們執行這個函數，那麼 只有0會被視作是False，其他所有數值都是True ：

Python中用==判斷相等，>表示大於，>=表示大於等於， <表示小於，<=表示小於等於，!=表示不等。

我們可以用and和or拼裝各個邏輯運算：

注意not，and，or之間的優先順序，其中not > and > or。如果分不清楚的話，可以用括弧強行改變運行順序。

關於list的判斷，我們常用的判斷有兩種，一種是剛才介紹的==，還有一種是is。我們有時候也會簡單實用is來判斷，那麼這兩者有什麼區別呢？我們來看下面的例子：

Python是全引用的語言，其中的對象都使用引用來表示。is判斷的就是 兩個引用是否指向同一個對象 ，而==則是判斷兩個引用指向的具體內容是否相等。舉個例子，如果我們把引用比喻成地址的話，is就是判斷兩個變數的是否指向同一個地址，比如說都是沿河東路XX號。而==則是判斷這兩個地址的收件人是否都叫張三。

顯然，住在同一個地址的人一定都叫張三，但是住在不同地址的兩個人也可以都叫張三，也可以叫不同的名字。所以如果a is b，那麼a == b一定成立，反之則不然。

Python當中對字元串的限制比較松， 雙引號和單引號都可以表示字元串 ，看個人喜好使用單引號或者是雙引號。我個人比較喜歡單引號，因為寫起來方便。

字元串也支持+操作，表示兩個字元串相連。除此之外，我們把兩個字元串寫在一起，即使沒有+，Python也會為我們拼接：

我們可以使用[]來查找字元串當中某個位置的字元，用 len 來計算字元串的長度。

我們可以在字元串前面 加上f表示格式操作 ，並且在格式操作當中也支持運算，比如可以嵌套上len函數等。不過要注意，只有Python3.6以上的版本支持f操作。

最後是None的判斷，在Python當中None也是一個對象， 所有為None的變數都會指向這個對象 。根據我們前面所說的，既然所有的None都指向同一個地址，我們需要判斷一個變數是否是None的時候，可以使用is來進行判斷，當然用==也是可以的，不過我們通常使用is。

理解了None之後，我們再回到之前介紹過的bool()函數，它的用途其實就是判斷值是否是空。所有類型的 默認空值會被返回False ，否則都是True。比如0，""，[], {}, ()等。

除了上面這些值以外的所有值傳入都會得到True。

Python當中的標准輸入輸出是 input和print 。

print會輸出一個字元串，如果傳入的不是字元串會自動調用__str__方法轉成字元串進行輸出。 默認輸出會自動換行 ，如果想要以不同的字元結尾代替換行，可以傳入end參數：

使用input時，Python會在命令行接收一行字元串作為輸入。可以在input當中傳入字元串，會被當成提示輸出：

Python支持 三元表達式 ，但是語法和C++不同，使用if else結構，寫成：

上段代碼等價於：

Python中用[]表示空的list，我們也可以直接在其中填充元素進行初始化：

使用append和pop可以在list的末尾插入或者刪除元素：

list可以通過[]加上下標訪問指定位置的元素，如果是負數，則表示 倒序訪問 。-1表示最後一個元素，-2表示倒數第二個，以此類推。如果訪問的元素超過數組長度，則會出發 IndexError 的錯誤。

list支持切片操作，所謂的切片則是從原list當中 拷貝 出指定的一段。我們用start: end的格式來獲取切片，注意，這是一個 左閉右開區間 。如果留空表示全部獲取，我們也可以額外再加入一個參數表示步長，比如[1:5:2]表示從1號位置開始，步長為2獲取元素。得到的結果為[1, 3]。如果步長設置成-1則代表反向遍歷。

如果我們要指定一段區間倒序，則前面的start和end也需要反過來，例如我想要獲取[3: 6]區間的倒序，應該寫成[6:3:-1]。

只寫一個:，表示全部拷貝，如果用is判斷拷貝前後的list會得到False。可以使用del刪除指定位置的元素，或者可以使用remove方法。

insert方法可以 指定位置插入元素 ，index方法可以查詢某個元素第一次出現的下標。

list可以進行加法運算，兩個list相加表示list當中的元素合並。 等價於使用extend 方法：

我們想要判斷元素是否在list中出現，可以使用 in關鍵字 ，通過使用len計算list的長度：

tuple和list非常接近，tuple通過()初始化。和list不同， tuple是不可變對象 。也就是說tuple一旦生成不可以改變。如果我們修改tuple，會引發TypeError異常。

由於小括弧是有改變優先順序的含義，所以我們定義單個元素的tuple， 末尾必須加上逗號 ，否則會被當成是單個元素：

tuple支持list當中絕大部分操作：

我們可以用多個變數來解壓一個tuple：

解釋一下這行代碼：

我們在b的前面加上了星號， 表示這是一個list 。所以Python會在將其他變數對應上值的情況下，將剩下的元素都賦值給b。

補充一點，tuple本身雖然是不可變的，但是 tuple當中的可變元素是可以改變的 。比如我們有這樣一個tuple：

我們雖然不能往a當中添加或者刪除元素，但是a當中含有一個list，我們可以改變這個list類型的元素，這並不會觸發tuple的異常：

dict也是Python當中經常使用的容器，它等價於C++當中的map，即 存儲key和value的鍵值對 。我們用{}表示一個dict，用:分隔key和value。

對 。我們用{}表示一個dict，用:分隔key和value。

dict的key必須為不可變對象，所以 list、set和dict不可以作為另一個dict的key ，否則會拋出異常：

我們同樣用[]查找dict當中的元素，我們傳入key，獲得value，等價於get方法。

我們可以call dict當中的keys和values方法，獲取dict當中的所有key和value的集合，會得到一個list。在Python3.7以下版本當中，返回的結果的順序可能和插入順序不同，在Python3.7及以上版本中，Python會保證返回的順序和插入順序一致：

我們也可以用in判斷一個key是否在dict當中，注意只能判斷key。

如果使用[]查找不存在的key，會引發KeyError的異常。如果使用 get方法則不會引起異常，只會得到一個None ：

setdefault方法可以 為不存在的key 插入一個value，如果key已經存在，則不會覆蓋它：

我們可以使用update方法用另外一個dict來更新當前dict，比如a.update(b)。對於a和b交集的key會被b覆蓋，a當中不存在的key會被插入進來：

我們一樣可以使用del刪除dict當中的元素，同樣只能傳入key。

Python3.5以上的版本支持使用**來解壓一個dict：

set是用來存儲 不重復元素 的容器，當中的元素都是不同的，相同的元素會被刪除。我們可以通過set()，或者通過{}來進行初始化。注意當我們使用{}的時候，必須要傳入數據，否則Python會將它和dict弄混。

set當中的元素也必須是不可變對象，因此list不能傳入set。

可以調用add方法為set插入元素：

set還可以被認為是集合，所以它還支持一些集合交叉並補的操作。

set還支持 超集和子集的判斷 ，我們可以用大於等於和小於等於號判斷一個set是不是另一個的超集或子集：

和dict一樣，我們可以使用in判斷元素在不在set當中。用可以拷貝一個set。

Python當中的判斷語句非常簡單，並且Python不支持switch，所以即使是多個條件，我們也只能 羅列if-else 。

我們可以用in來循環迭代一個list當中的內容，這也是Python當中基本的循環方式。

如果我們要循環一個范圍，可以使用range。range加上一個參數表示從0開始的序列，比如range(10)，表示[0, 10)區間內的所有整數：

如果我們傳入兩個參數，則 代表迭代區間的首尾 。

如果我們傳入第三個元素，表示每次 循環變數自增的步長 。

如果使用enumerate函數，可以 同時迭代一個list的下標和元素 ：

while循環和C++類似，當條件為True時執行，為false時退出。並且判斷條件不需要加上括弧：

Python當中使用 try和except捕獲異常 ，我們可以在except後面限制異常的類型。如果有多個類型可以寫多個except，還可以使用else語句表示其他所有的類型。finally語句內的語法 無論是否會觸發異常都必定執行 ：

在Python當中我們經常會使用資源，最常見的就是open打開一個文件。我們 打開了文件句柄就一定要關閉 ，但是如果我們手動來編碼，經常會忘記執行close操作。並且如果文件異常，還會觸發異常。這個時候我們可以使用with語句來代替這部分處理，使用with會 自動在with塊執行結束或者是觸發異常時關閉打開的資源 。

以下是with的幾種用法和功能：

凡是可以使用in語句來迭代的對象都叫做 可迭代對象 ，它和迭代器不是一個含義。這里只有可迭代對象的介紹，想要了解迭代器的具體內容，請移步傳送門：

Python——五分鍾帶你弄懂迭代器與生成器，夯實代碼能力

當我們調用dict當中的keys方法的時候，返回的結果就是一個可迭代對象。

我們 不能使用下標來訪問 可迭代對象，但我們可以用iter將它轉化成迭代器，使用next關鍵字來獲取下一個元素。也可以將它轉化成list類型，變成一個list。

使用def關鍵字來定義函數，我們在傳參的時候如果指定函數內的參數名， 可以不按照函數定義的順序 傳參：

可以在參數名之前加上*表示任意長度的參數，參數會被轉化成list：

也可以指定任意長度的關鍵字參數，在參數前加上**表示接受一個dict：

當然我們也可以兩個都用上，這樣可以接受任何參數：

傳入參數的時候我們也可以使用*和**來解壓list或者是dict：

Python中的參數 可以返回多個值 ：

函數內部定義的變數即使和全局變數重名，也 不會覆蓋全局變數的值 。想要在函數內部使用全局變數，需要加上 global 關鍵字，表示這是一個全局變數：

Python支持 函數式編程 ，我們可以在一個函數內部返回一個函數：

Python中可以使用lambda表示 匿名函數 ，使用:作為分隔，:前面表示匿名函數的參數，:後面的是函數的返回值：

我們還可以將函數作為參數使用map和filter，實現元素的批量處理和過濾。關於Python中map、rece和filter的使用，具體可以查看之前的文章：

五分鍾帶你了解map、rece和filter

我們還可以結合循環和判斷語來給list或者是dict進行初始化：

使用 import語句引入一個Python模塊 ，我們可以用.來訪問模塊中的函數或者是類。

我們也可以使用from import的語句，單獨引入模塊內的函數或者是類，而不再需要寫出完整路徑。使用from import *可以引入模塊內所有內容（不推薦這么干）

可以使用as給模塊內的方法或者類起別名：

我們可以使用dir查看我們用的模塊的路徑：

這么做的原因是如果我們當前的路徑下也有一個叫做math的Python文件，那麼 會覆蓋系統自帶的math的模塊 。這是尤其需要注意的，不小心會導致很多奇怪的bug。

我們來看一個完整的類，相關的介紹都在注釋當中

以上內容的詳細介紹之前也有過相關文章，可以查看：

Python—— slots ，property和對象命名規范

下面我們來看看Python當中類的使用：

這里解釋一下，實例和對象可以理解成一個概念，實例的英文是instance，對象的英文是object。都是指類經過實例化之後得到的對象。

繼承可以讓子類 繼承父類的變數以及方法 ，並且我們還可以在子類當中指定一些屬於自己的特性，並且還可以重寫父類的一些方法。一般我們會將不同的類放在不同的文件當中，使用import引入，一樣可以實現繼承。

我們創建一個蝙蝠類：

我們再創建一個蝙蝠俠的類，同時繼承Superhero和Bat：

執行這個類：

我們可以通過yield關鍵字創建一個生成器，每次我們調用的時候執行到yield關鍵字處則停止。下次再次調用則還是從yield處開始往下執行：

除了yield之外，我們還可以使用()小括弧來生成一個生成器：

關於生成器和迭代器更多的內容，可以查看下面這篇文章：

五分鍾帶你弄懂迭代器與生成器，夯實代碼能力

我們引入functools當中的wraps之後，可以創建一個裝飾器。裝飾器可以在不修改函數內部代碼的前提下，在外麵包裝一層其他的邏輯:

裝飾器之前也有專門的文章詳細介紹，可以移步下面的傳送門：

一文搞定Python裝飾器，看完面試不再慌

不知道有多少小夥伴可以看到結束，原作者的確非常厲害，把Python的基本操作基本上都囊括在裡面了。如果都能讀懂並且理解的話，那麼Python這門語言就算是入門了。

如果你之前就有其他語言的語言基礎，我想本文讀完應該不用30分鍾。當然在30分鍾內學會一門語言是不可能的，也不是我所提倡的。但至少通過本文我們可以做到熟悉Python的語法，知道大概有哪些操作，剩下的就要我們親自去寫代碼的時候去體會和運用了。

根據我的經驗，在學習一門新語言的前期，不停地查閱資料是免不了的。希望本文可以作為你在使用Python時候的查閱文檔。

最後，我這里有各種免費的編程類資料，有需要的及時私聊我，回復"學習"，分享給大家，正在發放中............

E. python字典操作函數

字典是一種通過名字或者關鍵字引用的得數據結構，其鍵可以是數字、字元串、元組，這種結構類型也稱之為映射。字典類型是Python中唯一內建的映射類型，基本的操作包括如下：

(1)len()：返回字典中鍵—值對的數量；

(2)d[k]:返回關鍵字對於的值；

(3)d[k]=v:將值關聯到鍵值k上；

(4)del d[k]:刪除鍵值為k的項；

(5)key in d:鍵值key是否在d中，是返回True，否則返回False。

(6)clear函數：清除字典中的所有項

(7)函數：返回一個具有相同鍵值的新字典；deep()函數使用深復制，復制其包含所有的值，這個方法可以解決由於副本修改而使原始字典也變化的問題

(8)fromkeys函數：使用給定的鍵建立新的字典，鍵默認對應的值為None

(9)get函數：訪問字典成員

(10)has_key函數：檢查字典中是否含有給出的鍵

(11)items和iteritems函數:items將所有的字典項以列表方式返回，列表中項來自（鍵，值），iteritems與items作用相似，但是返回的是一個迭代器對象而不是列表

(12)keys和iterkeys：keys將字典中的鍵以列表形式返回，iterkeys返回鍵的迭代器

(13)pop函數：刪除字典中對應的鍵

(14)popitem函數：移出字典中的項

(15)setdefault函數：類似於get方法，獲取與給定鍵相關聯的值，也可以在字典中不包含給定鍵的情況下設定相應的鍵值

(16)update函數：用一個字典更新另外一個字典

(17) values和itervalues函數：values以列表的形式返回字典中的值，itervalues返回值得迭代器，由於在字典中值不是唯一的，所以列表中可以包含重復的元素

一、字典的創建

1.1 直接創建字典

d={'one':1,'two':2,'three':3}

printd

printd['two']

printd['three']

運算結果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'three':3,'two':2,'one':1}

>>>

1.2 通過dict創建字典

# _*_ coding:utf-8 _*_

items=[('one',1),('two',2),('three',3),('four',4)]

printu'items中的內容:'

printitems

printu'利用dict創建字典，輸出字典內容:'

d=dict(items)

printd

printu'查詢字典中的內容:'

printd['one']

printd['three']

運算結果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

items中的內容:

[('one',1), ('two',2), ('three',3), ('four',4)]

利用dict創建字典，輸出字典內容:

{'four':4,'three':3,'two':2,'one':1}

查詢字典中的內容:

>>>

或者通過關鍵字創建字典

# _*_ coding:utf-8 _*_

d=dict(one=1,two=2,three=3)

printu'輸出字典內容:'

printd

printu'查詢字典中的內容:'

printd['one']

printd['three']

運算結果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

輸出字典內容:

{'three':3,'two':2,'one':1}

查詢字典中的內容:

>>>

二、字典的格式化字元串

# _*_ coding:utf-8 _*_

d={'one':1,'two':2,'three':3,'four':4}

printd

print"three is %(three)s."%d

運算結果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'four':4,'three':3,'two':2,'one':1}

threeis3.

>>>

三、字典方法

3.1 clear函數：清除字典中的所有項

# _*_ coding:utf-8 _*_

d={'one':1,'two':2,'three':3,'four':4}

printd

d.clear()

printd

運算結果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'four':4,'three':3,'two':2,'one':1}

{}

>>>

請看下面兩個例子

3.1.1

# _*_ coding:utf-8 _*_

d={}

dd=d

d['one']=1

d['two']=2

printdd

d={}

printd

printdd

運算結果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'two':2,'one':1}

{}

{'two':2,'one':1}

>>>

3.1.2

# _*_ coding:utf-8 _*_

d={}

dd=d

d['one']=1

d['two']=2

printdd

d.clear()

printd

printdd

運算結果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'two':2,'one':1}

{}

{}

>>>

3.1.2與3.1.1唯一不同的是在對字典d的清空處理上，3.1.1將d關聯到一個新的空字典上，這種方式對字典dd是沒有影響的，所以在字典d被置空後，字典dd裡面的值仍舊沒有變化。但是在3.1.2中clear方法清空字典d中的內容，clear是一個原地操作的方法，使得d中的內容全部被置空，這樣dd所指向的空間也被置空。

3.2 函數：返回一個具有相同鍵值的新字典

# _*_ coding:utf-8 _*_

x={'one':1,'two':2,'three':3,'test':['a','b','c']}

printu'初始X字典：'

printx

printu'X復制到Y：'

y=x.()

printu'Y字典：'

printy

y['three']=33

printu'修改Y中的值，觀察輸出：'

printy

printx

printu'刪除Y中的值，觀察輸出'

y['test'].remove('c')

printy

printx

運算結果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

初始X字典：

{'test': ['a','b','c'],'three':3,'two':2,'one':1}

X復制到Y：

Y字典：

{'test': ['a','b','c'],'one':1,'three':3,'two':2}

修改Y中的值，觀察輸出：

{'test': ['a','b','c'],'one':1,'three':33,'two':2}

{'test': ['a','b','c'],'three':3,'two':2,'one':1}

刪除Y中的值，觀察輸出

{'test': ['a','b'],'one':1,'three':33,'two':2}

{'test': ['a','b'],'three':3,'two':2,'one':1}

>>>

註：在復制的副本中對值進行替換後，對原來的字典不產生影響，但是如果修改了副本，原始的字典也會被修改。deep函數使用深復制，復制其包含所有的值，這個方法可以解決由於副本修改而使原始字典也變化的問題。

# _*_ coding:utf-8 _*_

fromimportdeep

x={}

x['test']=['a','b','c','d']

y=x.()

z=deep(x)

printu'輸出：'

printy

printz

printu'修改後輸出：'

x['test'].append('e')

printy

printz

運算輸出：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

輸出：

{'test': ['a','b','c','d']}

{'test': ['a','b','c','d']}

修改後輸出：

{'test': ['a','b','c','d','e']}

{'test': ['a','b','c','d']}

>>>

3.3 fromkeys函數：使用給定的鍵建立新的字典，鍵默認對應的值為None

# _*_ coding:utf-8 _*_

d=dict.fromkeys(['one','two','three'])

printd

運算輸出：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'three':None,'two':None,'one':None}

>>>

或者指定默認的對應值

# _*_ coding:utf-8 _*_

d=dict.fromkeys(['one','two','three'],'unknow')

printd

運算結果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'three':'unknow','two':'unknow','one':'unknow'}

>>>

3.4 get函數：訪問字典成員

# _*_ coding:utf-8 _*_

d={'one':1,'two':2,'three':3}

printd

printd.get('one')

printd.get('four')

運算結果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'three':3,'two':2,'one':1}

1

None

>>>

註：get函數可以訪問字典中不存在的鍵，當該鍵不存在是返回None

3.5 has_key函數：檢查字典中是否含有給出的鍵

# _*_ coding:utf-8 _*_

d={'one':1,'two':2,'three':3}

printd

printd.has_key('one')

printd.has_key('four')

運算結果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'three':3,'two':2,'one':1}

True

False

>>>

3.6 items和iteritems函數:items將所有的字典項以列表方式返回，列表中項來自（鍵，值），iteritems與items作用相似，但是返回的是一個迭代器對象而不是列表

# _*_ coding:utf-8 _*_

d={'one':1,'two':2,'three':3}

printd

list=d.items()

forkey,valueinlist:

  printkey,':',value

運算結果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'three':3,'two':2,'one':1}

three :3

two :2

one :1

>>>

# _*_ coding:utf-8 _*_

d={'one':1,'two':2,'three':3}

printd

it=d.iteritems()

fork,vinit:

  print"d[%s]="%k,v

運算結果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'three':3,'two':2,'one':1}

d[three]=3

d[two]=2

d[one]=1

>>>

3.7 keys和iterkeys：keys將字典中的鍵以列表形式返回，iterkeys返回鍵的迭代器

# _*_ coding:utf-8 _*_

d={'one':1,'two':2,'three':3}

printd

printu'keys方法：'

list=d.keys()

printlist

printu'\niterkeys方法：'

it=d.iterkeys()

forxinit:

  printx

運算結果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'three':3,'two':2,'one':1}

keys方法：

['three','two','one']

iterkeys方法：

three

two

one

>>>

3.8 pop函數：刪除字典中對應的鍵

# _*_ coding:utf-8 _*_

d={'one':1,'two':2,'three':3}

printd

d.pop('one')

printd

運算結果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'three':3,'two':2,'one':1}

{'three':3,'two':2}

>>>

3.9 popitem函數：移出字典中的項

# _*_ coding:utf-8 _*_

d={'one':1,'two':2,'three':3}

printd

d.popitem()

printd

運算結果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'three':3,'two':2,'one':1}

{'two':2,'one':1}

>>>

3.10 setdefault函數：類似於get方法，獲取與給定鍵相關聯的值，也可以在字典中不包含給定鍵的情況下設定相應的鍵值

# _*_ coding:utf-8 _*_

d={'one':1,'two':2,'three':3}

printd

printd.setdefault('one',1)

printd.setdefault('four',4)

printd

運算結果：

{'three':3,'two':2,'one':1}

{'four':4,'three':3,'two':2,'one':1}

>>>

3.11 update函數：用一個字典更新另外一個字典

# _*_ coding:utf-8 _*_

d={

  'one':123,

  'two':2,

  'three':3

  }

printd

x={'one':1}

d.update(x)

printd

運算結果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

{'three':3,'two':2,'one':123}

{'three':3,'two':2,'one':1}

>>>

3.12 values和itervalues函數：values以列表的形式返回字典中的值，itervalues返回值得迭代器，由於在字典中值不是唯一的，所以列表中可以包含重復的元素

# _*_ coding:utf-8 _*_

d={

  'one':123,

  'two':2,

  'three':3,

  'test':2

  }

printd.values()

運算結果：

=======RESTART: C:\Users\Mr_Deng\Desktop\test.py=======

[2,3,2,123]

>>>

F. Python中的dict怎麼用

#字典的添加、刪除、修改操作
dict={"a":"apple","b":"banana","g":"grape","o":"orange"}
dict["w"]="watermelon"
del(dict["a"])
dict["g"]="grapefruit"
printdict.pop("b")
printdict
dict.clear()
printdict
#字典的遍歷
dict={"a":"apple","b":"banana","g":"grape","o":"orange"}
forkindict:
print"dict[%s]="%k,dict[k]
#字典items()的使用
dict={"a":"apple","b":"banana","c":"grape","d":"orange"}
#每個元素是一個key和value組成的元組，以列表的方式輸出
printdict.items()
#調用items()實現字典的遍歷
dict={"a":"apple","b":"banana","g":"grape","o":"orange"}
for(k,v)indict.items():
print"dict[%s]="%k,v
#調用iteritems()實現字典的遍歷
dict={"a":"apple","b":"banana","c":"grape","d":"orange"}
printdict.iteritems()
fork,vindict.iteritems():
print"dict[%s]="%k,v
for(k,v)inzip(dict.iterkeys(),dict.itervalues()):
print"dict[%s]="%k,v


#使用列表、字典作為字典的值
dict={"a":("apple",),"bo":{"b":"banana","o":"orange"},"g":["grape","grapefruit"]}
printdict["a"]
printdict["a"][0]
printdict["bo"]
printdict["bo"]["o"]
printdict["g"]
printdict["g"][1]

dict={"a":"apple","b":"banana","c":"grape","d":"orange"}
#輸出key的列表
printdict.keys()
#輸出value的列表
printdict.values()
#每個元素是一個key和value組成的元組，以列表的方式輸出
printdict.items()
dict={"a":"apple","b":"banana","c":"grape","d":"orange"}
it=dict.iteritems()
printit
#字典中元素的獲取方法
dict={"a":"apple","b":"banana","c":"grape","d":"orange"}
printdict
printdict.get("c","apple")
printdict.get("e","apple")
#get()的等價語句
D={"key1":"value1","key2":"value2"}
if"key1"inD:
printD["key1"]
else:
print"None"
#字典的更新
dict={"a":"apple","b":"banana"}
printdict
dict2={"c":"grape","d":"orange"}
dict.update(dict2)
printdict
#udpate()的等價語句
D={"key1":"value1","key2":"value2"}
E={"key3":"value3","key4":"value4"}
forkinE:
D[k]=E[k]
printD
#字典E中含有字典D中的key
D={"key1":"value1","key2":"value2"}
E={"key2":"value3","key4":"value4"}
forkinE:
D[k]=E[k]
printD
#設置默認值
dict={}
dict.setdefault("a")
printdict
dict["a"]="apple"
dict.setdefault("a","default")
printdict
#調用sorted()排序
dict={"a":"apple","b":"grape","c":"orange","d":"banana"}
printdict
#按照key排序
printsorted(dict.items(),key=lambdad:d[0])
#按照value排序
printsorted(dict.items(),key=lambdad:d[1])
#字典的淺拷貝
dict={"a":"apple","b":"grape"}
dict2={"c":"orange","d":"banana"}
dict2=dict.()
printdict2

#字典的深拷貝
import
dict={"a":"apple","b":{"g":"grape","o":"orange"}}
dict2=.deep(dict)
dict3=.(dict)
dict2["b"]["g"]="orange"
printdict
dict3["b"]["g"]="orange"
printdict

G. python 列表內有字典怎麼使用

Python字典是另一種可變容器模型，且可存儲任意類型對象，如字元串、數字、元組等其他容器模型。
一、創建字典
字典由鍵和對應值成對組成。字典也被稱作關聯數組或哈希表。基本語法如下：

復制代碼代碼如下:
dict = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'}

也可如此創建字典：

復制代碼代碼如下:
dict1 = { 'abc': 456 };
dict2 = { 'abc': 123, 98.6: 37 };

注意：
每個鍵與值用冒號隔開（:），每對用逗號，每對用逗號分割，整體放在花括弧中（{}）。
鍵必須獨一無二，但值則不必。
值可以取任何數據類型，但必須是不可變的，如字元串，數或元組。
二、訪問字典里的值
把相應的鍵放入熟悉的方括弧，如下實例:

復制代碼代碼如下:
#!/usr/bin/python

dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'};

print "dict['Name']: ", dict['Name'];
print "dict['Age']: ", dict['Age'];
#以上實例輸出結果：
#dict['Name']: Zara
#dict['Age']: 7

如果用字典里沒有的鍵訪問數據，會輸出錯誤如下：

復制代碼代碼如下:
#!/usr/bin/python

dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'};

print "dict['Alice']: ", dict['Alice'];

#以上實例輸出結果：
#dict['Zara']:
#Traceback (most recent call last):
# File "test.py", line 4, in <mole>
# print "dict['Alice']: ", dict['Alice'];
#KeyError: 'Alice'[/code]
三、修改字典
向字典添加新內容的方法是增加新的鍵/值對，修改或刪除已有鍵/值對如下實例:

復制代碼代碼如下:
#!/usr/bin/python

dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'};

dict['Age'] = 8; # update existing entry
dict['School'] = "DPS School"; # Add new entry

print "dict['Age']: ", dict['Age'];
print "dict['School']: ", dict['School'];
#以上實例輸出結果：
#dict['Age']: 8
#dict['School']: DPS School

四、刪除字典元素
能刪單一的元素也能清空字典，清空只需一項操作。
顯示刪除一個字典用del命令，如下實例：

復制代碼代碼如下:
#!/usr/bin/python

dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'};

del dict['Name']; # 刪除鍵是'Name'的條目
dict.clear(); # 清空詞典所有條目
del dict ; # 刪除詞典

print "dict['Age']: ", dict['Age'];
print "dict['School']: ", dict['School'];
#但這會引發一個異常，因為用del後字典不再存在：
dict['Age']:
#Traceback (most recent call last):
# File "test.py", line 8, in <mole>
# print "dict['Age']: ", dict['Age'];
#TypeError: 'type' object is unsubscriptable

五、字典鍵的特性
字典值可以沒有限制地取任何python對象，既可以是標準的對象，也可以是用戶定義的，但鍵不行。
兩個重要的點需要記住：
1）不允許同一個鍵出現兩次。創建時如果同一個鍵被賦值兩次，後一個值會被記住，如下實例：

復制代碼代碼如下:
#!/usr/bin/python

dict = {'Name': 'Zara', 'Age': 7, 'Name': 'Manni'};

print "dict['Name']: ", dict['Name'];
#以上實例輸出結果：
#dict['Name']: Manni

2）鍵必須不可變，所以可以用數，字元串或元組充當，所以用列表就不行，如下實例：

復制代碼代碼如下:
#!/usr/bin/python

dict = {['Name']: 'Zara', 'Age': 7};

print "dict['Name']: ", dict['Name'];
#以上實例輸出結果：
#Traceback (most recent call last):
# File "test.py", line 3, in <mole>
# dict = {['Name']: 'Zara', 'Age': 7};
#TypeError: list objects are unhashable

六、字典內置函數&方法
Python字典包含了以下內置函數：
1、cmp(dict1, dict2)：比較兩個字典元素。
2、len(dict)：計算字典元素個數，即鍵的總數。
3、str(dict)：輸出字典可列印的字元串表示。
4、type(variable)：返回輸入的變數類型，如果變數是字典就返回字典類型。
Python字典包含了以下內置方法：
1、radiansdict.clear()：刪除字典內所有元素
2、radiansdict.()：返回一個字典的淺復制
3、radiansdict.fromkeys()：創建一個新字典，以序列seq中元素做字典的鍵，val為字典所有鍵對應的初始值
4、radiansdict.get(key, default=None)：返回指定鍵的值，如果值不在字典中返回default值
5、radiansdict.has_key(key)：如果鍵在字典dict里返回true，否則返回false
6、radiansdict.items()：以列表返回可遍歷的(鍵, 值) 元組數組
7、radiansdict.keys()：以列表返回一個字典所有的鍵
8、radiansdict.setdefault(key, default=None)：和get()類似, 但如果鍵不已經存在於字典中，將會添加鍵並將值設為default
9、radiansdict.update(dict2)：把字典dict2的鍵/值對更新到dict里
10、radiansdict.values()：以列表返回字典中的所有值

H. python字典如何添加字典

python字典添加字典的方法：
1、首先建立一個新的字典
2、調用updata（）函數，把新字典裡面的鍵值對更新到dict里
3、列印dict，字典添加成功。
結果如下

I. python3 defaultdict 和 dict的區別

yangyzh
Python中dict詳解

python3.0以上，print函數應為print（），不存在dict.iteritems()這個函數。

在python中寫中文注釋會報錯，這時只要在頭部加上# coding=gbk即可

#字典的添加、刪除、修改操作
dict = {"a" : "apple", "b" : "banana", "g" : "grape", "o" : "orange"}
dict["w"] = "watermelon"
del(dict["a"])
dict["g"] = "grapefruit"
print dict.pop("b")
print dict
dict.clear()
print dict
#字典的遍歷
dict = {"a" : "apple", "b" : "banana", "g" : "grape", "o" : "orange"}
for k in dict:
print "dict[%s] =" % k,dict[k]
#字典items()的使用
dict = {"a" : "apple", "b" : "banana", "c" : "grape", "d" : "orange"}
#每個元素是一個key和value組成的元組，以列表的方式輸出
print dict.items()
#調用items()實現字典的遍歷
dict = {"a" : "apple", "b" : "banana", "g" : "grape", "o" : "orange"}
for (k, v) in dict.items():
print "dict[%s] =" % k, v
#調用iteritems()實現字典的遍歷
dict = {"a" : "apple", "b" : "banana", "c" : "grape", "d" : "orange"}
print dict.iteritems()
for k, v in dict.iteritems():
print "dict[%s] =" % k, v
for (k, v) in zip(dict.iterkeys(), dict.itervalues()):
print "dict[%s] =" % k, v

#使用列表、字典作為字典的值
dict = {"a" : ("apple",), "bo" : {"b" : "banana", "o" : "orange"}, "g" : ["grape","grapefruit"]}
print dict["a"]
print dict["a"][0]
print dict["bo"]
print dict["bo"]["o"]
print dict["g"]
print dict["g"][1]

dict = {"a" : "apple", "b" : "banana", "c" : "grape", "d" : "orange"}
#輸出key的列表
print dict.keys()
#輸出value的列表
print dict.values()
#每個元素是一個key和value組成的元組，以列表的方式輸出
print dict.items()
dict = {"a" : "apple", "b" : "banana", "c" : "grape", "d" : "orange"}
it = dict.iteritems()
print it
#字典中元素的獲取方法
dict = {"a" : "apple", "b" : "banana", "c" : "grape", "d" : "orange"}
print dict
print dict.get("c", "apple")
print dict.get("e", "apple")
#get()的等價語句
D = {"key1" : "value1", "key2" : "value2"}
if "key1" in D:
print D["key1"]
else:
print "None"
#字典的更新
dict = {"a" : "apple", "b" : "banana"}
print dict
dict2 = {"c" : "grape", "d" : "orange"}
dict.update(dict2)
print dict
#udpate()的等價語句
D = {"key1" : "value1", "key2" : "value2"}
E = {"key3" : "value3", "key4" : "value4"}
for k in E:
D[k] = E[k]
print D
#字典E中含有字典D中的key
D = {"key1" : "value1", "key2" : "value2"}
E = {"key2" : "value3", "key4" : "value4"}
for k in E:
D[k] = E[k]
print D
#設置默認值
dict = {}
dict.setdefault("a")
print dict
dict["a"] = "apple"
dict.setdefault("a","default")
print dict
#調用sorted()排序
dict = {"a" : "apple", "b" : "grape", "c" : "orange", "d" : "banana"}
print dict
#按照key排序
print sorted(dict.items(), key=lambda d: d[0])
#按照value排序
print sorted(dict.items(), key=lambda d: d[1])
#字典的淺拷貝
dict = {"a" : "apple", "b" : "grape"}
dict2 = {"c" : "orange", "d" : "banana"}
dict2 = dict.()
print dict2

#字典的深拷貝
import
dict = {"a" : "apple", "b" : {"g" : "grape","o" : "orange"}}
dict2 = .deep(dict)
dict3 = .(dict)
dict2["b"]["g"] = "orange"
print dict
dict3["b"]["g"] = "orange"
print dict

補充：
1 初始化
>>> d = dict(name='visaya', age=20)
>>> d = dict(zip(['name', 'age'], ['visaya', 20]))

#dict.fromkeys(listkeys, default=0) 把listkeys中的元素作為key均賦值為value，默認為0
>>> d = dict.fromkeys(['a', 'b'], 1)
>>> d
{'a': 1, 'b': 1}
2 字典視圖和幾何
dict.keys()類似信使可以進行交集和並集等集合操作（類似集合，因為不存在重復的項），但dict.values()不可以進行如上操作。

>>> k = d.keys()
>>> k
dict_keys(['a', 'b'])
>>> list(k)
['a', 'b']
>>> k | {'x': 3}
{'a', 'x', 'b'}
>>> k | {'x'}
{'a', 'x', 'b'}
>>> k | {'x', 'y'}
{'a', 'y', 'b', 'x'}
>>> k & {'x'}
set()
>>> v = d.values()
>>> v
dict_values([1, 2])
>>> v | {'x'}
Traceback (most recent call last):
File "<stdin>", line 1, in <mole>
TypeError: unsupported operand type(s) for |: 'dict_values' and 'set'
3 排序字典鍵
兩種方法:
3.1 sort:
>>> Ks = list(d.keys())
>>> Ks.sort()
>>> for k in Ks:
... print(k, d[k])
...
a 1
b 2
3.2 sorted:
>>> for k in sorted(d.keys()):
... print(k, d[k])
...
a 1
b 2

3.3 注意
>>> for k in list(d.keys()).sort():
... print(k, d[k])
...
Traceback (most recent call last):
File "<stdin>", line 1, in <mole>
TypeError: 'NoneType' object is not iterable

出錯原因：
list.sort() list.append()函數都是對自身的操作，沒有返回值，故需先將list(d.keys())的結果保存下來，在結果上進行sort()
4 常用函數
4.1 get()
D.get(k[, d]) => D[k] if k in D else d. d defaults to none.
4.2 pop()
D.pop(value[, d]) => Remove specified key and return the corresponding value. If key is not found, d is returned if given, otherwise KeyError is raised.
4.3 udpate()
D.update(E, **F) -> None. Update D from dict/iterable E and F.
If E has a .keys() method, does: for k in E: D[k] = E[k]
If E lacks .keys() method, does: for (k, v) in E: D[k] = v
In either case, this is followed by: for k in F: D[k] = F[k]

>>> d = dict(name='visaya', age=21)
>>> d1= {'age': 20, 'sex': 'male'}
>>> d2 = zip(['a', 'b'], [1, 2])

>>> d.update(d1)
>>> d
{'age': 20, 'name': 'visaya', 'sex': 'male'}
#for k in d1: d[k] = d1[k]

>>> d.update(d2)
>>> d
{'age': 20, 'name': 'visaya', 'sex': 'male'}
#for (k, v) in d2: d[k] = v
4.4 del()
del D[key]
4.5 clear()
4.6 ()
Python中的dict
初始化
構造方法創建
Python代碼
d = dict()
d = dict(name="nico", age=23)
d = dict((['name', "nico"], ['age', 23]))
當然還有更方便，簡單的
Python代碼
d = {}
d = {"name":"nico", "age":23}

遍歷
通過對key的遍歷，遍歷整個dict

Python代碼
d = {"name":"nico", "age":23}
for key in d:
print "key=%s, value=%s" % (key, d[key])

for key in d.iterkeys():
print "key=%s, value=%s" % (key, d[key])

for key in d.keys():
print "key=%s, value=%s" % (key, d[key])

for key in iter(d):
print "key=%s, value=%s" % (key, d[key])

for key,item in d.items():
print "key=%s, value=%s" % (key, item)

當然也可以直接遍歷value

Python代碼
d = {"name":"nico", "age":23}
for value in d.values():
print value

for key,value in d.viewitems():
print "key=%s, value=%s" % (key, value)

for value in d.viewvalues():
print "value=%s" % (value)
這里values和viewvalues的區別

後者返回的是該字典的一個view對象，類似資料庫中的view，當dict改變時，該view對象也跟著改變

常用方法

Python代碼
d = {"name":"nico", "age":23}
d["name"] = "aaaa"
d["address"] = "abcdefg...."
print d #{'age': 23, 'name': 'aaaa', 'address': 'abcdefg....'}

獲取dict值
Python代碼
print d["name"] #nico
print d.get("name") #nico

如果key不在dict中，返回default，沒有為None
Python代碼
print d.get("namex", "aaa") #aaa
print d.get("namex") #None

排序sorted()
Python代碼
d = {"name":"nico", "age":23}
for key in sorted(d):
print "key=%s, value=%s" % (key, d[key])
#key=age, value=23
#key=name, value=nico

刪除del
Python代碼
d = {"name":"nico", "age":23}
Python代碼
del d["name"]
#如果key不在dict中，拋出KeyError
del d["names"]
Python代碼
Traceback (most recent call last):
File "F:\workspace\project\pydev\src\ddd\ddddd.py", line 64, in <mole>
del d["names"]
KeyError: 'names'

清空clear()
Python代碼
d = {"name":"nico", "age":23}
d.clear()
print d #{}

()
Python代碼
d1 = d.() #{'age': 23, 'name': 'nico'}
#使用返回view對象
d2 = d1.viewitems() #dict_items([('age', 23), ('name', 'nico')])
#修改字典d1，新增元素
d1["cc"] = "aaaaaa"
print d2
#dict_items([('cc', 'aaaaaa'), ('age', 23), ('name', 'nico')])

pop(key[, default])
如果key在dict中，返回，不在返回default
Python代碼
#如果key在dict中，返回，不在返回default
print d.pop("name", "niccco") #nico
print d.pop("namezzz", "niccco") #niccco
#key不在dict中，且default值也沒有，拋出KeyError
print d.pop("namezzz") #此處拋出KeyError

popitem()
刪除並返回dict中任意的一個(key,value)隊，如果字典為空會拋出KeyError
Python代碼
d = {"name":"nico", "age":23}
print d.popitem() #('age', 23)
print d.popitem() #('name', 'nico')
#此時字典d已為空
print d.popitem() #此處會拋出KeyError

update([other])
將字典other中的元素加到dict中，key重復時將用other中的值覆蓋
Python代碼
d = {"name":"nico", "age":23}
d2 = {"name":"jack", "abcd":123}
d.update(d2)
print d #{'abcd': 123, 'age': 23, 'name': 'jack'}