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