Python中dict字典使用方法

参考链接：

1. Python 字典(Dictionary)
2. Python 优雅的操作字典
3. Python中创建字典的几种方法

Dictionary 是 Python 的内置数据类型之一，它定义了键和值之间一对一的关系。

一、dict字典有很多常用的函数

dict.clear() 删除字典中所有元素
dict.copy() 返回字典(浅复制)的一个副本
dict.get(key,default=None) 对字典dict中的键key,返回它对应的值value，如果字典中不存在此键，则返回default 的值(注意，参数default 的默认值为None)
dict.has_key(key) 如果键(key)在字典中存在，返回True，否则返回False
dict.items() 返回一个包含字典中(键, 值)对元组的列表
dict.keys() 返回一个包含字典中键的列表
dict.values() 返回一个包含字典中所有值的列表
dict.pop(key[, default]) 和方法get()相似，如果字典中key 键存在，删除并返回dict[key]，如果key 键不存在，且没有给出default 的值，引发KeyError 异常。

二、Python代码：

>>> dict1 = {"b" : "blue", "c" : "color", "g" : "gray", "r" : "red"}
>>> dict1["g"] = "green" #修改
>>> dict1
{'c': 'color', 'b': 'blue', 'r': 'red', 'g': 'green'}
>>> dict1["o"] = "orange" #添加
>>> dict1
{'c': 'color', 'b': 'blue', 'r': 'red', 'o': 'orange', 'g': 'green'}
>>> del(dict1["c"])  #删除
>>> dict1
{'b': 'blue', 'r': 'red', 'o': 'orange', 'g': 'green'}
>>> dict1.pop("b")  #pop用法
'blue'
>>> dict1
{'r': 'red', 'o': 'orange', 'g': 'green'}
>>> dict.clear() #清除
>>> dict
{}

//

>>> dict1 = {"b" : "blue", "c" : "color", "g" : "gray", "r" : "red"}
>>> dict1.get("c","none") #get用法
'color'
>>> dict1.get("o","none")
'none'

>>> dict1.get("o","none")
'none'
>>> dict1.has_key("b") #has_key用法
True
>>> dict1.has_key("o")
False

>>> dict1.keys()# dict.keys()用法
['c', 'b', 'r', 'g']
>>> dict1.values() #dict.values()用法
['color', 'blue', 'red', 'gray']
>>> dict1.items() #dict.items()用法
[('c', 'color'), ('b', 'blue'), ('r', 'red'), ('g', 'gray')]

//

>>> dict1 = {"b" : "blue", "c" : "color", "g" : "gray", "r" : "red"}
>>> dict2 = {"g" : "green", "o" : "orange"}
>>> dict3 = dict1.copy()     #copy()用法
>>> dict3
{'c': 'color', 'b': 'blue', 'r': 'red', 'g': 'gray'}
>>> dict1
{'c': 'color', 'b': 'blue', 'r': 'red', 'g': 'gray'}

>>> dict1.update(dict2)     #update()用法
>>> dict1

{'c': 'color', 'b': 'blue', 'g': 'green', 'r': 'red', 'o': 'orange'}

/

>>> dict1 = {"b" : "blue", "c" : "color", "g" : "gray", "r" : "red"}
>>> for(k,v) in dict1.items():  #items()用法
print "dict1[%s] =" % k, v
dict1[c] = color
dict1[b] = blue
dict1[r] = red
dict1[g] = gray
>>> for (k,v) in dict1.iteritems(): #iteritems()用法
print "dict1[%s] =" % k, v
dict1[c] = color
dict1[b] = blue
dict1[r] = red
dict1[g] = gray

items()和iteritems()方法都普遍用于for循环的迭代中，不同的是items()返回的是列表对象，而iteritems()返回的是迭代器对象。两者的用法差不多，但iteritems()的性能更快。

---

4. python: dict(字典) 操作

key-value

名称	唯一性	数据类型	可变性
key (键)	唯一	数字/字符串/元组	不可
value (值)	不唯一	任意	可变

字典定义

dict = { "say": "hello", "python":3, 10:0.999, 20:["Hi", 60], (1, 2):True}

assert dict == {'say': 'hello', 'python': 3, 10: 0.999, 20: ['Hi', 60], (1, 2):True}
 
 
1
2
3

字典访问

通过指定key值访问对应的value：

dict = { "say": "hello", "python":3, 10:0.999, 20:["Hi", 60]}

assert dict["say"] == "hello"
assert dict[20] == ["Hi", 60]
# 不存在时 报KeyError
try:
    print(dict["city"]) 
except KeyError:
    pass
 
 
1
2
3
4
5
6
7
8
9

字典长度

dict = {'city': 'nanjing', 'university': 'NUAA', 'college': 'cs', 'degree': 'master'}

# 字典长度
assert len(dict) == 4
 
 
1
2
3
4

字典打印

字典打印（以字符串形式）。

dict = {'city': 'nanjing', 'university': 'NUAA', 'college': 'cs', 'degree': 'master'}

# 字典打印（以字符串形式）
assert str(dict) == "{'city': 'nanjing', 'university': 'NUAA', 'college': 'cs', 'degree': 'master'}"
 
 
1
2
3
4

字典复制

浅复制。

dict = {'city': 'nanjing', 'university': 'NUAA', 'college': 'cs', 'degree': 'master'}

# 字典复制
assert dict.copy() == dict
assert id(dict.copy()) != id(dict)
 
 
1
2
3
4
5

字典取值

不修改 字典：

dict.get(key, default=None)

Args:

• key: 字典中要查找的键。
• default: 如果指定键的值不存在时，返回 该默认值 。

dict = {'city': 'nanjing', 'university': 'NUAA', 'college': 'cs', 'degree': 'master'}

# 返回指定键的值
assert dict.get("city") == "nanjing"

# 返回指定键的值，如果值在字典中，default值无效
assert dict.get("city", "Shanghai") == "nanjing"

# 返回指定键的值，如果值不在字典中，返回default值
assert dict.get("province", "jiangshu") == "jiangshu"
 
 
1
2
3
4
5
6
7
8
9
10

修改 字典：

dict.setdefault(key, default=None)

Args:

• key: 字典中要查找的键。
• default: 如果指定键的值不存在时，返回 该默认值值，并 修改 字典，添加上该 key-value对 。

dict = {'city': 'nanjing', 'university': 'NUAA'}    # nanjing

# 和get()类似
print(dict.setdefault('city'))

# 但如果键不存在于字典中，将会返回default值。 并且修改字典，添加键并将值设为default
print(dict.setdefault('college', 'cs'))    # cs
print(dict.setdefault('location'))    # None
print(dict)    #  {'city': 'nanjing', 'university': 'NUAA', 'college': 'cs', 'location': None}
 
 
1
2
3
4
5
6
7
8
9

key 存在

if i in dict

dict = {'city': 'nanjing', 'university': 'NUAA'}

# 检测键 city 是否存在
if 'city' in dict:
    print("键 city 存在")
else :
    print("键 city 不存在")
 
 
1
2
3
4
5
6
7

可遍历的 key-value 数组

dict.items()

以列表 返回 可遍历的 (key-value)元组数组 。

dict = {'city': 'nanjing', 'university': 'NUAA', 'college': 'cs', 'degree': 'master'}

print(type(dict.items())) # <class 'dict_items'>

print(dict.items()) # dict_items([('city', 'nanjing'), ('university:', 'NUAA'), ('college', 'cs'), ('degree', 'master')])

for i, j in dict.items():
    print(i, ":\t", j)
# city :     nanjing
# university :   NUAA
# college :  cs
# degree :   master
 
 
1
2
3
4
5
6
7
8
9
10
11
12

key列表

dict.keys()

以 dict列表 返回字典中的所有key。

dict = {'city': 'nanjing', 'university': 'NUAA', 'college': 'cs', 'degree': 'master'}

# 以列表返回一个字典所有的key
print(dict.keys())    # dict_keys(['city', 'university', 'college', 'degree'])

for i in dict.keys():
    print(i)
# city
# university
# college
# degree

# 也可转化为list进行操作
list_ = list(dict.keys())
list_.sort()
for i in list_:
    print(i)
# city
# college
# degree
# university
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

value列表

dict.values()

以 dict列表 返回字典中的所有value。

dict = {'city': 'nanjing', 'university': 'NUAA', 'college': 'cs', 'degree': 'master'}

# 以列表返回一个字典所有的value
print(dict.values())    # dict_values(['nanjing', 'NUAA', 'cs', 'master'])

for i in dict.values():
    print(i)
# nanjing
# NUAA
# cs
# master

# 也可转化为list进行操作
list_ = list(dict.values())
list_.sort()
for i in list_:
    print(i)
# NUAA
# cs
# master
# nanjing
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

字典合并

通过 update 合并字典。

dict = {"city":"nanjing", "university":"NUAA"}
dict_2 = {"college":"cs", "degree":"master"}

dict.update(dict_2)
assert dict == {'city': 'nanjing', 'university': 'NUAA', 'college': 'cs', 'degree': 'master'}
 
 
1
2
3
4
5

字典删除

通过 .pop() ：

dict.pop(key[,default])

删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。

dict = {'city': 'nanjing', 'university': 'NUAA'}

# 删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。
print(dict.pop('city'))    # nanjing
print(dict)    # {'university': 'NUAA'}
print(dict.pop('city', 'college'))    # college
 
 
1
2
3
4
5
6

通过 del ：

dict_1 = {'city': 'nanjing', 'university': 'NUAA', 'college': 'cs', 'degree': 'master'}

# 删除key-value:  'city': 'nanjing'
del dict_1['city']    
assert dict_1 == {'university': 'NUAA', 'college': 'cs', 'degree': 'master'}

# 删除字典
del dict_1            
try:
    print(dict_1)
except NameError:
    pass
 
 
1
2
3
4
5
6
7
8
9
10
11
12

通过 .popitem() ：

dict.popitem()

随机返回并删除字典中的一对键和值(一般删除末尾对)。

dict = {'city': 'nanjing', 'university': 'NUAA', 'college': 'cs', 'degree': 'master'}

# 随机返回并删除字典中的一对键和值(一般删除末尾对)。
print(dict.popitem())    # ('degree', 'master')
print(dict)    # {'city': 'nanjing', 'university': 'NUAA', 'college': 'cs'}
 
 
1
2
3
4
5

字典清空

通过 .clear() ：

dict_1 = {'city': 'nanjing', 'university': 'NUAA', 'college': 'cs', 'degree': 'master'}

# 清空字典
dict_1.clear()        
assert dict_1 == {}
 
 
1
2
3
4
5