當前位置:首頁 » 編程語言 » python遍歷字典的值

python遍歷字典的值

發布時間: 2023-03-22 13:48:59

python如何無限遍歷字典中的value,在不知道字典裡面有幾層字典的時候

遞歸。

用這個函數把dict裡面的所有value用遞歸的方法提取到一個空list裡面

defdict2flatlist(d,l):
print(d)
forxind.keys():
iftype(d[x])==dict:
dict2flatlist(d[x],l)
else:
l.append(d[x])

d={1:"a",2:"b",3:{4:"c",5:"d",6:{7:"e"}},8:"f"}

l=[]
dict2flatlist(d,l)
print(l)

希望對你有幫助

Ⅱ Python字典鍵值對的添加和遍歷

添加鍵值對
首先定義一個空字典
>>> dic={}
直接對字典中不存在的key進行賦值來添加
>>> dic['name']='zhangsan'
>>> dic
{'name': 'zhangsan'}
如果key或value都是變數也可以用這種方法
>>> key='age'
>>> value=30
>>> dic[key]=value
>>> dic
{'age': 30. 'name': 'zhangsan'}
這里可以看到字典中的數據並不是按先後順序排列的,如果有興趣,可以搜一搜數據結構中的——哈希表
從python3.7開始,字典按照插入順序,實現了有序。修改一個已存在的key的值,不影響順序,如果刪了一個key後再添加該key,該key會被添加至末尾。標准json庫的mp(s)/load(s)也是有序的
還可以用字典的setdefault方法
>>> dic.setdefault('sex','male')
'male'
>>> key='id'
>>> value='001'
>>> dic.setdefault(key,value)
'001'
>>> dic
{'id': '001', 'age': 30. 'name': 'zhangsan', 'sex': 'male'}

Ⅲ 新手小白:python3中如何遍歷列表中的字典的value並存放到一個變數中,最好是循環遍歷

values_list=[forvaluein_dict.values()for_dictin_list]

Ⅳ python自學筆記13:元組和字典的操作

定義元組(tuple):

t1=(1,2,3,4)#多個數據元組

t2=(1,)#如果元組內只有一個數據,也需要手逗號隔開,否則這個數據將是他本身的類型。

元組的操作:

元組類型數據不支持修改,可查找

查找:

按下標查找:

print(t1[1])

函數查找:

print(t1.index(1))返回對應下標,如果數據不存在,程序將報錯

print(t1.count(1))統計數據在元組當中出現的次數

print(len(t1))統計元組當中的數據個數

注意:當元組內嵌套列表數據,可以通過下標的方法對列表數據進行修改如:

t3=(1,2,["a","b"])

t3[2][0]=c #t3的值將變為(1,2,["c","b"])

——————————————————

——————————————————

定義字典(dict)

字典的特點

1:符號為{}

2:數據為鍵(key)值(value)對形式,每個鍵值對之間用逗號隔開如:

dict1={"name":"小明","age":18,"gender:男"}

字典的操作:

dict1["name"]="小紅"

dict1["id"]=3

如果key存在,將修改其所對應的值。如果不存在,將在字典最後添加該鍵值對

2.刪除數據

del():刪除字典或刪除字典內的鍵值對

del dict1["name"] 刪除字典內的鍵值對,如果刪除的key不存在,程序將會報錯

del(del)刪除字典

clear(dict1) 清空字典

3.查找數據

一.按照key進行查找,最後返回相對應的值

二.按函數進行查找:

(1) get(key,默認值):

如果查找的key不存在則返回所寫的默認值,如果不寫默認值則返回None

dict1={"name":"小明","age":18,"gender:男"}

print(dict1.get("name")) #小明

print(dict1.get("id",110)) # 110

——————————————————

(2) keys():返回字典內的所有key 可用for遍歷

print(dict1.keys())

返回 ["name","age","gender"]

for key in dict1.keys():

..print(key)

逐行輸出name age gender

——————————————————

(3) values(): 返回字典內的值 可用for遍歷

print(dict1.values())

返回["小明",18,"男"]

for value dict1.values():

..print(value)

逐行輸出小明 18 男

——————————————————

(4) items():將字典內的數據以元組的形式返回

print(dict1.items()) 可用for遍歷

返回[("name","小明"),("age",18),("gender","男")]

for item in dict1.items():

..print(item)

逐行輸出 ("name","小明") ("age",18)("gender","男")

——————————————————

遍歷字典鍵值對(拆包) 可在for內使用兩個臨時變數

dict1={"name":"小明","age":18,"gender:男"}

for key,value in dict1.items():

..print(f"{key}=value")

逐行輸出:

name=小明 age=18 gender=男

Ⅳ Python中字典創建、遍歷、添加等實用操作技巧合集

欄位是Python是字典中唯一的鍵-值類型,是Python中非常重要的數據結構,因其用哈希的方式存儲數據,其復雜度為O(1),速度非常快。下面列出字典的常用的用途.
一、字典中常見方法列表
代碼如下:
#方法
#描述
-------------------------------------------------------------------------------------------------
D.clear()
#移除D中的所有項
D.()
#返回D的副本
D.fromkeys(seq[,val])
#返回從seq中獲得的鍵和被設置為val的值的字典。可做類方法調用
D.get(key[,default])
#如果D[key]存在,將其返回;否則返回給定的默認值None
D.has_key(key)
#檢查D是否有給定鍵key
D.items()
#返回表示D項的(鍵,值)對列表
D.iteritems()
#從D.items()返回的(鍵,值)對中返回一個可迭代的對象
D.iterkeys()
#從D的鍵中返回一個可迭代對象
D.itervalues()
#從D的值中返回一個可迭代對象
D.keys()
#返回D鍵的列表
D.pop(key[,d])
#移除並且返回對應給定鍵key或給定的默認值D的值
D.popitem()
#從D中移除任意一項,並將其作為(鍵,值)對返回
D.setdefault(key[,default])
#如果D[key]存在則將其返回;否則返回默認值None
D.update(other)
#將other中的每一項加入到D中。
D.values()
#返回D中值的列表
二、創建字典的五種方法
方法一:
常規方法
代碼如下:
#
如果事先能拼出整個字典,則此方法比較方便
>>>
D1
=
{'name':'Bob','age':40}
方法二:
動態創建

代碼如下:
#
如果需要動態地建立字典的一個欄位,則此方法比較方便
>>>
D2
=
{}
>>>
D2['name']
=
'Bob'
>>>
D2['age']
=
40
>>>
D2
{'age':
40,
'name':
'Bob'}
方法三:
dict--關鍵字形式
代碼如下:
#
代碼比較少,但鍵必須為字元串型。常用於函數賦值
>>>
D3
=
dict(name='Bob',age=45)
>>>
D3
{'age':
45,
'name':
'Bob'}
方法四:
dict--鍵值序列
代碼如下:
#
如果需要將鍵值逐步建成序列,則此方式比較有用,常與zip函數一起使用
>>>
D4
=
dict([('name','Bob'),('age',40)])
>>>
D4
{'age':
40,
'name':
'Bob'}

代碼如下:
>>>
D
=
dict(zip(('name','bob'),('age',40)))
>>>
D
{'bob':
40,
'name':
'age'}
方法五:
dict--fromkeys方法#
如果鍵的值都相同的話,用這種方式比較好,並可以用fromkeys來初始化

代碼如下:
>>>
D5
=
dict.fromkeys(['A','B'],0)
>>>
D5
{'A':
0,
'B':
0}
如果鍵的值沒提供的話,默認為None
代碼如下:
>>>
D3
=
dict.fromkeys(['A','B'])
>>>
D3
{'A':
None,
'B':
None}
三、字典中鍵值遍歷方法

代碼如下:
>>>
D
=
{'x':1,
'y':2,
'z':3}
#
方法一
>>>
for
key
in
D:
print
key,
'=>',
D[key]
y
=>
2
x
=>
1
z
=>
3
>>>
for
key,
value
in
D.items():
#
方法二
print
key,
'=>',
value
y
=>
2
x
=>
1
z
=>
3
>>>
for
key
in
D.iterkeys():
#
方法三
print
key,
'=>',
D[key]
y
=>
2
x
=>
1
z
=>
3
>>>
for
value
in
D.values():
#
方法四
print
value
2
1
3
>>>
for
key,
value
in
D.iteritems():
#
方法五
print
key,
'=>',
value
y
=>
2
x
=>
1
z
=>
3
Note:用D.iteritems(),
D.iterkeys()的方法要比沒有iter的快的多。
四、字典的常用用途之一代替switch
在C/C++/Java語言中,有個很方便的函數switch,比如:
代碼如下:
public
class
test
{
public
static
void
main(String[]
args)
{
String
s
=
"C";
switch
(s){
case
"A":
System.out.println("A");
break;
case
"B":
System.out.println("B");
break;
case
"C":
System.out.println("C");
break;
default:
System.out.println("D");
}
}
}
在Python中要實現同樣的功能,
方法一,就是用if,
else語句來實現,比如:

代碼如下:
from
__future__
import
division
def
add(x,
y):
return
x
+
y
def
sub(x,
y):
return
x
-
y
def
mul(x,
y):
return
x
*
y
def
div(x,
y):
return
x
/
y
def
operator(x,
y,
sep='+'):
if
sep
==
'+':
print
add(x,
y)
elif
sep
==
'-':
print
sub(x,
y)
elif
sep
==
'*':
print
mul(x,
y)
elif
sep
==
'/':
print
div(x,
y)
else:
print
'Something
Wrong'
print
__name__
if
__name__
==
'__main__':
x
=
int(raw_input("Enter
the
1st
number:
"))
y
=
int(raw_input("Enter
the
2nd
number:
"))
s
=
raw_input("Enter
operation
here(+
-
*
/):
")
operator(x,
y,
s)
方法二,用字典來巧妙實現同樣的switch的功能,比如:

代碼如下:
#coding=gbk
from
__future__
import
division
x
=
int(raw_input("Enter
the
1st
number:
"))
y
=
int(raw_input("Enter
the
2nd
number:
"))
def
operator(o):
dict_oper
=
{
'+':
lambda
x,
y:
x
+
y,
'-':
lambda
x,
y:
x
-
y,
'*':
lambda
x,
y:
x
*
y,
'/':
lambda
x,
y:
x
/
y}
return
dict_oper.get(o)(x,
y)
if
__name__
==
'__main__':
o
=
raw_input("Enter
operation
here(+
-
*
/):
")
print
operator(o)

Ⅵ python3字典遍歷

(1)遍歷key值

在使用上,for key in a和 for key in a.keys():完全等價。

(2)遍歷value值

(3)遍歷字典項

(4)遍歷字典健值

在使用上for key,value in a.items()與for (key,value) in a.items()完全等價

Ⅶ python語言字典里還有列表列表是value值,遍歷出列表怎麼寫代碼

不知道你是不是這個意思,

字典調用values()方法會返回Value值所構成的列表,通過兩個循環就能遍歷字典里的列表

data={'a':[1,2,3],'b':[4,5,6]}
forlindata.values():
foriteminl:
printitem

Ⅷ python循環遍歷字典元素問題求指教

你的x,y是代表的未知元素吧,不然a就只有{('x','y'):(0,0)}這一個元素了。下面說問題:

對於字典的key值遍歷可以用items()函數來實現,比如下面的代碼:

a={('a','b'):(0,0),('c','d'):(1,1),('e','f'):(2,2)}
fori,jina.items():
print(i,':',j)

輸出的結果是:

('c', 'd') : (1, 1)

('e', 'f') : (2, 2)

('a', 'b') : (0, 0)

也就是說對for i,j in a.items()這句話,i得到是字典的key值,j得到的是字典的value,如果想只遍歷字典的key值,也就是你要的('x','y'),那麼把print(i,' : ',j)改成print(i)就可以了(具體輸出格式你自己定製就好,不一定按我的)

Ⅸ python如何遍歷多鍵值的字典並使用對應鍵的值來替換

dict = {('絲印兩處', '絲印二處', '絲印兩道', '絲印二道', '絲印2道'): '絲印2處', ('絲印三處', '絲印三道', '絲印3道'): '絲印3處'}
ss = ["黑色MI0000C-BK002 含三道絲印", "黑色MI0000C-BK002 含絲印三道", "黑色MI0000C-BK002 含3道絲印"]
for s in ss:
for k, v in dict.items():
for src in k:
s = s.replace(src, v)
print(s)

注意:你的dict不足以涵蓋你的輸入,所以只有中間那句是替換了

Ⅹ python怎樣遍歷.py的內容

列表的遍歷
方法一:通過for循環
li = [i for i in range(10)]
for i in li:
print(i)
方法二:通過while循環
# 雖然for循環已經很好用了,但是在有些情況下,使用while循環可以更靈活
# 只需要將判斷條件設置為小於列表長度,即可完成列表通過while循環的遍歷
li = [i for i in range(10)]
i = 0
while i < len(li):
print(li[i])
i += 1
方法三:配合enumerate使用,同時獲取列表的索引
li = [i + 1 for i in range(10)]

# 此時,i為一個元組,元組的第一個元素為索引,第二個元素為原列表的元素
# 因此,在遍歷列表的同時,需要同時獲取坐標的情況下,可以配合enumerate()一起使用
for i in enumerate(li):
print(i)
字典的遍歷
字典的遍歷和列表有一些不同,因為字典有鍵和值兩個關鍵部分。默認的遍歷情況,是遍歷字典的鍵,當然,可以通過字典的鍵取得值,也可以直接遍歷值,或者直接遍歷鍵和值。

方法一:直接使用for循環
直接使用for循環對一個字典進行遍歷,默認取得的是字典的鍵

dt = {i: i + 1 for i in range(10)}

for i in dt:
print("字典的鍵:", i) # 字典的鍵
print("字典的值:", dt[i]) # 字典的值
方法二:遍歷dict.keys()
這種方法與方法一的效果其實是一樣的,同樣是獲取字典的鍵

dt = {i: i + 1 for i in range(10)}

for i in dt.keys():
print("字典的鍵:", i) # 字典的鍵
print("字典的值:", dt[i]) # 字典的值
方法三:遍歷dict.values()
這種方法與方法一和二很不相同,因為它只獲取了字典的值

dt = {i: i + 1 for i in range(10)}

# 這是很特殊的方法,因為它沒有獲取字典的鍵
for i in dt.values():
print("字典的值:", i) # 此時i不再是字典的鍵,而是值
方法四:遍歷dict.items()
這種方法一般來說要更好,因為它同時獲取到了字典的鍵和值,而且性能上要高於先獲取鍵,再通過鍵獲取對應的值

dt = {i: i + 1 for i in range(10)}

for i in dt.items():
print("字典的鍵值對:", i)
print("字典的鍵:", i[0])
print("字典的值:", i[1])
總結
1,列表的遍歷比較簡單,除了配合enumerate()使用,可以同步獲取索引以外,並沒有特別值得糾結的。

2,字典的遍歷方法比較多,其中第四種是能適用於一切情況的,前兩種也可以適用於一切情況,但是如果你同時需要獲取鍵和值,性能不如第四種要好。第三種比較特別,除非你真的只需要字典的值,否則它在多數情況下是不能夠滿足需求的。

熱點內容
python動態載入腳本 發布:2024-04-18 09:51:26 瀏覽:888
windows上編譯器 發布:2024-04-18 09:35:24 瀏覽:205
如何發壓縮文件 發布:2024-04-18 09:35:19 瀏覽:276
白頭神探ftp 發布:2024-04-18 09:29:48 瀏覽:384
極速上傳工具 發布:2024-04-18 09:28:15 瀏覽:901
什麼是空調的配置 發布:2024-04-18 09:20:30 瀏覽:670
幾百人訪問需要什麼級別伺服器 發布:2024-04-18 09:20:18 瀏覽:489
17款傳奇什麼配置 發布:2024-04-18 09:06:43 瀏覽:698
圖層php 發布:2024-04-18 08:54:30 瀏覽:503
江西省資料庫 發布:2024-04-18 08:17:42 瀏覽:904