python字典方法
㈠ python字典推導法，怎麼輸出嵌套字典
實際上各種推導式的本質就是for循環, 它們之間的區別只是取值方式的不同和表達式的不同
首先, 字典的取值方式有兩種: 按key取值, 使用get方法取值
其次, 字典推導式的表達式部分需要寫成 key:value 的形式
如果要使用字典推導式推導一個嵌套字典
例如:
infos = {"張三":{ "age":18, "salary":5000},
"李四":{"age":19, "salary":8000},
"王五":{ "age":20, "salary":6000}}
要從infos這個嵌套的字典中推導出一個形如{"張三":5000, "李四":8000, "王五":6000}的字典
首先可以考慮最內層的推導式:
names = [name for name in infos]
這樣就得到了一個姓名的列表: ["張三", "李四", "王五"]
再迭代這個列表, 生成字典的每一項, 於是字典生成式應該像下面這樣:
salary_dict = {name:薪資 for name in names}
在這里, 因為name正好是infos這個字典的key, 所以可以使用name從字典infos中取出對應的薪資, 於是有下面的形式:
salary_dict = {name:infos[name]["salary"] for name in names}
這里就用到的字典的用key取值的方式, 當然, 也可以用get方法取值, 例如下面的形式:
salary_dict = {name:infos.get(name).get("salary") for name in names}
這兩種方式都是可以的, 根據個人喜好選擇就好
為了顯得逼格更高, 可以把names的列表推導式和salary_dict的字典推導式結合起來, 於是就得到下面的形式:
salary_dict = {name:infos[name]["salary"] for name in (name for name in infos)}
到這里, 你會發現表達式里有好多name, 顯得非常重復, 實際上這里並不需要列表推導式, 直接從字典里迭代出來的key就是name了, 所以最終的形式如下:
salary_dict = {name:infos[name]["salary"] for name in infos}
這里為了得到一個比較簡單的結果而繞了一個大圈子, 是為了說明更加通用方法, 對於這個例子, 很容易就能得出結果的哈
㈡ python中字典的get方法疑問
max dic默認比較的對象和返回的對象都是鍵，比如
print(max(dic))得到C，C是鍵
上述方法希望獲得最大的value對應的鍵，key是被比較的屬性，由鍵映射到值，用get方法
但我覺得上面的方法過於晦澀，容易混淆，簡潔易懂的可以改成
print(next(k for k, v in dic.items()
if v == max(dic.values())))
㈢ 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)
㈣ Python中創建字典的幾種方法總結
1.傳統的文字表達式：
>>>d={'name':'Allen','age':21,'gender':'male'}
>>>d
{'age':21,'name':'Allen','gender':'male'}
如果你可以事先拼出整個字典，這種方式是很方便的。
2.動態分配鍵值：
>>>d={}
>>>d['name']='Allen'
>>>d['age']=21
>>>d['gender']='male'
>>>d
{'age':21,'name':'Allen','gender':'male'}
如果你需要一次動態地建立一個字典的一個欄位，那麼這種方式比較合適。
字典與列表不同，不能通過偏移量進行復制，只能通過鍵來讀取或賦值，所以也可以這樣為字典賦值，當然訪問不存在的鍵會報錯：
>>>d[1]='abcd'
>>>d
{1:'abcd','age':21,'name':'Allen','gender':'male'}
>>>d[2]
Traceback(mostrecentcalllast):
File"<pyshell#9>",line1,in<mole>d[2]
KeyError:212345678
3.字典鍵值表
>>>c=dict(name='Allen',age=14,gender='male')
>>>c
{'gender':'male','name':'Allen','age':14}
因為這種形式語法簡單，不易出錯，所以非常流行。
這種形式所需的代碼比常量少，但是鍵必須都是字元串才行，所以下列代碼會報錯：
>>>c=dict(name='Allen',age=14,gender='male',1='abcd')
SyntaxError:keywordcan'tbeanexpression
4.字典鍵值元組表
>>>e=dict([('name','Allen'),('age',21),('gender','male')])
>>>e
{'age':21,'name':'Allen','gender':'male'}
如果你需要在程序運行時把鍵和值逐步建成序列，那麼這種方式比較有用。
5.所有鍵的值都相同或者賦予初始值：
>>>f=dict.fromkeys(['height','weight'],'normal')
>>>f
{'weight':'normal','height':'normal'}
㈤ 軟體測試中，python字典遍歷的幾種方法
在python2.2之前，還只能用beys等字典方法來獲取鍵（因為不允許直接迭代字典）。
如果只需要值，可以使用d.values代替d.keys。
㈥ 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()：以列表返回字典中的所有值
㈦ python中字典常用的方法有哪些，分別有什麼作用
寫法：字典序列[key] = 值 ***字典為可變類型
常用方法：
1、# 新增字典中的數據
dict1 = {'name':'huu','age':20,'gender':'男'}
dict1['id'] = 133
print(dict1)
2、# 修改字典中的數據
dict1['name'] = 'xiauaiguai'
print(dict1)
3、刪除字典或刪除字典中指定鍵值對
del()/del:
dict1 = {'name':'huanghu','age':30,'gender':'男'}
# del(dict1) 直接將字典刪除了，運行報錯
del dict1['name']
print(dict1)
# del dict1[names] 刪除不存在的key，運行報錯
4、清空字典
clear():
dict1.clear() # 清空字典
print(dict1)
5、查找
key值查找
如果當前查找的key存在則返回對應的值，否則則報錯
函數查找
get():如果當前查找的key不存在則返回第二個參數值（默認值），
如果省略第二個參數則返回 None
key()
dict1 = {'name':'huhu','age':20,'gender':'男'}
print(dict1['name']) # huhu
print(dict1['id']) # 報錯
# 1, get()查找
print(dict1.get('name')) # huanghu
print(dict1.get('id',133)) # 133--如果當前查找的key不存在則返回第二個參數值（默認值）
print(dict1.get('id')) # None--如果省略第二個參數則返回 None
# 2, keys() 查找字典中所有的key，返回可迭代對象
print(dict1.keys()) # dict_keys(['name', 'age', 'gender'])
# 3，values() 查找字典中所有的values,
print(dict1.values()) # dict_values(['huanghu', 30, '男'])
# 4, items() 查找字典中所有的鍵值對，返回可迭代對象，裡面的數據是元組，
元組數據1是字典中的key，元組數據2是字典key對應的值
print(dict1.items()) # dict_items([('name', 'huahu'), ('age', 20), ('gender', '男')])