當前位置:首頁 » 編程語言 » python的dict更新

python的dict更新

發布時間: 2022-12-30 04:11:32

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

熱點內容
編程器解讀 發布:2025-07-03 03:22:49 瀏覽:22
中國電信加密通信業務 發布:2025-07-03 03:06:00 瀏覽:520
腳本家的台詞 發布:2025-07-03 03:05:50 瀏覽:708
arcgisforpython 發布:2025-07-03 03:05:46 瀏覽:898
期計演算法 發布:2025-07-03 02:56:53 瀏覽:404
不同域訪問 發布:2025-07-03 02:49:05 瀏覽:818
多槽編程 發布:2025-07-03 02:47:42 瀏覽:919
sql2008錯誤233 發布:2025-07-03 02:28:52 瀏覽:168
創建資料庫語句mysql 發布:2025-07-03 02:14:34 瀏覽:146
python量化投資 發布:2025-07-03 02:05:11 瀏覽:804