Python字典详解

字典（dictionary）是除列表以外Python中最灵活的内置数据结构类型。列表是有序的对象集合，字典是无序的对象集合。
两者的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取的。
字典由索引（key）和它对应的值（value）组成（key和value之间用:冒号隔开）。用“{ }”标识。

dict = {\'Name\': \'Runoob\', \'Age\': 7, \'Class\': \'First\'}
或这样写：
dict = {
    \'Name\': \'Runoob\',
    \'Age\': 7,
    \'Class\': \'First\',
}
print(dict.keys())        #输出所有键
print(dict.values())        #输出所有值
print(dict[\'Name\'])        #输出键为’Name’的值
Print(dict)            #输出完整的字典
以上例子输出结果为：
dict_keys([\'Class\', \'Age\', \'Name\'])   #无序的
dict_values([\'First\', 7, \'Runoob\'])
Runoob
{\'Name\': \'Runoob\', \'Class\': \'First\', \'Age\': 7}

字典的介绍

字典是另一种可变容器模型，且可存储任意类型对象。（字典是无序的）
字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中 ,格式如下所示：
d = {key1 : value1, key2 : value2 }
键必须是唯一的，但值则不必。
值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。

一个简单的字典实例：

dict = {\'Alice\': \'2341\', \'Beth\': \'9102\', \'Cecil\': \'3258\'}
也可如此创建字典：
dict1 = { \'abc\': 456 }
dict2 = { \'abc\': 123, 98.6: 37 }

访问字典里的值
把相应的键放入到方括号中，如下实例:

实例
#!/usr/bin/python3
dict = {\'Name\': \'Runoob\', \'Age\': 7, \'Class\': \'First\'}
print ("dict[\'Name\']: ", dict[\'Name\'])
print ("dict[\'Age\']: ", dict[\'Age\'])
以上实例输出结果：
dict[\'Name\']: Runoob
dict[\'Age\']: 7

如果用字典里没有的键访问数据，会输出错误如下：

实例
#!/usr/bin/python3
dict = {\'Name\': \'Runoob\', \'Age\': 7, \'Class\': \'First\'};
print ("dict[\'Alice\']: ", dict[\'Alice\'])
以上实例输出结果：
Traceback (most recent call last):
File "test.py", line 5, in <module>
print ("dict[\'Alice\']: ", dict[\'Alice\'])
KeyError: \'Alice\'

字典的特性

字典值可以是任何的 python 对象，既可以是标准的对象，也可以是用户定义的，但键不行。
两个重要的点需要记住：

1）不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住，如下实例：
实例
#!/usr/bin/python3
dict = {\'Name\': \'Runoob\', \'Age\': 7, \'Name\': \'小菜鸟\'}
print ("dict[\'Name\']: ", dict[\'Name\'])
以上实例输出结果：
dict[\'Name\']: 小菜鸟
2）键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行，如下实例：
实例
#!/usr/bin/python3
dict = {[\'Name\']: \'Runoob\', \'Age\': 7}
print ("dict[\'Name\']: ", dict[\'Name\'])
以上实例输出结果：

Traceback (most recent call last):
File "test.py", line 3, in <module>
dict = {[\'Name\']: \'Runoob\', \'Age\': 7}
TypeError: unhashable type: \'list\'

创建字典方式

#1、{}定义
d1 = {"name":"egon","age":18,"sex":"man"}
print(d1,type(d1)) #{\'name\': \'egon\', \'age\': 18, \'sex\': \'man\'} <class \'dict\'>

#使用dict定义
#空字典
d2 = dict() #或者 d2 = {}
print(d2,type(d2)) #{} <class \'dict\'>

d3 = dict(x=1,y=2,z=3)
print(d3,type(d3)) #{\'x\': 1, \'y\': 2, \'z\': 3} <class \'dict\'>

数据类型转换

#将列表转成字典
info = [
    ["name", "egon"],
    ["age", 18],
    ["gender", "male"],
]

#方式一：普通
d = {}

for k,v in info:  #解压赋值
    d[k] = v

print(d,type(d)) #{\'name\': \'egon\', \'age\': 18, \'gender\': \'male\'} <class \'dict\'>

#方式二：使用dict方法
d1 = dict(info)
print(d1,type(d1)) #{\'name\': \'egon\', \'age\': 18, \'gender\': \'male\'} <class \'dict\'>

修改/添加字典元素

向字典添加新内容的方法是增加新的键/值对，修改已有键/值对如下实例:
注意：如果要修改的键不存在，则会自动创建一个

实例
#!/usr/bin/python3
dict = {\'Name\': \'Runoob\', \'Age\': 7, \'Class\': \'First\'}
dict[\'Age\'] = 8; # 更新 Age
dict[\'School\'] = "菜鸟教程" # 添加信息

print ("dict[\'Age\']: ", dict[\'Age\'])
print ("dict[\'School\']: ", dict[\'School\'])
以上实例输出结果：
dict[\'Age\']: 8
dict[\'School\']: 菜鸟教程

删除字典元素

能删单一的元素也能清空字典，清空只需一项操作。
1、用pop方法删除（标准的删除姿势）

代码
dict = {\'Name\': \'Runoob\', \'Age\': 7, \'Class\': \'First\'}
dict.pop(\'Class\')
print(dict)
执行结果
{\'Name\': \'Runoob\', \'Age\': 7}

2、用del命令删：
实例

dict = {\'Name\': \'Runoob\', \'Age\': 7, \'Class\': \'First\'}
del dict[\'Name\'] # 删除键 \'Name\'
print(dict)

//执行结果
{\'Age\': 7, \'Class\': \'First\'}

3、popitem()随机删除

dict = {\'Name\': \'Runoob\', \'Age\': 7, \'Class\': \'First\'}
dict.popitem()
print(dict)
执行结果
{\'Age\': 7, \'Class\': \'First\'}

查找字典中的元素

//代码
info = {\'stu1101\':\'TengLan Wu\',\'stu1102\': \'LongZe Luola\', \'stu1103\': \'XiaoZe Maliya\'}\'}
print(\'stu1102\'in info)     #标准用法
print(info.get(\'stu1103\'))   #获取
print(info[\'stu1102\'])      #查找键为’stu1102’的值
print(info)                #输出整个字典
print(info.keys())            #输出字典info的所有键
print(info.values())            #输出字典info的所有值
执行结果
True
XiaoZe Maliya
LongZe Luola
{\'stu1103\': \'XiaoZe Maliya\', \'stu1102\': \'LongZe Luola\', \'stu1101\': \'TengLan Wu\'}
dict_keys([\'stu1103\', \'stu1102\', \'stu1101\'])
dict_values([\'XiaoZe Maliya\', \'LongZe Luola\', \'TengLan Wu\'])

#如果一个key不存在，就报错，get不会，不存在只返回None
//print(info[\'stu1105\'])
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: \'stu1105\'

//print(info.get(\'stu1105\'))　　#推荐使用get
None

多级字典嵌套及操作

data={
    \'盐城市\':{
        \'滨海县\':{
            \'东坎镇\':{\'友好村\'},
            \'五汛镇\':{\'青龙村\'},
            \'蔡桥镇\':{\'当尖村\'},
        },
        \'响水县\':{
            \'响水镇\':{\'东园社区\'},
        },
        \'射阳县\':{
            \'千秋镇\':{\'渠东村\'},
        },
    },
    \'南京市\':{
        \'玄武区\':{
            \'新街口街道\':{\'长江路社区\'},
        },
        \'秦淮区\':{
            \'秦虹街道\':{\'中牌楼社区\'},
        },
        \'建邺区\':{
            \'南湖街道\':{\'南湖社区\'},
        },

    },
}

字典内置函数&方法

Python字典包含了以下内置函数：

 

Python字典包含以下内置方法

clear()删除字典内所有元素

//描述
Python 字典 clear() 函数用于删除字典内所有元素。
//语法
clear()方法语法：
dict.clear()
//参数
NA。
//返回值
该函数没有任何返回值。
//实例
以下实例展示了 clear()函数的使用方法：
#!/usr/bin/python3
dict = {\'Name\': \'Zara\', \'Age\': 7}
print ("字典长度 : %d" % len(dict))
dict.clear()
print ("字典删除后长度 : %d" % len(dict))
以上实例输出结果为：
字典长度 : 2
字典删除后长度 : 0

View Code

Python 字典 copy() 方法返回一个字典的浅复制。

//语法
copy()方法语法：
dict.copy()
//参数
NA。
//返回值
返回一个字典的浅复制。
//实例
以下实例展示了 copy()函数的使用方法：
实例
#!/usr/bin/python3
dict1 = {\'Name\': \'Runoob\', \'Age\': 7, \'Class\': \'First\'}
dict2 = dict1.copy()
print ("新复制的字典为 : ",dict2)
以上实例输出结果为：
新复制的字典为 :  {\'Name\': \'Runoob\', \'Age\': 7, \'Class\': \'First\'}

View Code

直接引用、浅拷贝、深拷贝的区别
可以通过以下实例说明：

# !/usr/bin/python
# -*- coding: UTF-8 -*-

import copy

D1 = {\'user\': \'runoob\', \'num\': [1, 2, 3]} # 原始数据
D2 = D1 # 直接引用：D2和D1整体指向同一对象。
D3 = D1.copy() # 浅拷贝：D3和D1的父对象是一个独立的对象，但是他们的子对象还是指向同一对象。
D4 = copy.deepcopy(D1) # 深拷贝：D4和D1的整体是一个独立的对象。

D1[\'user\'] = \'root\' # 修改父对象D1
D1[\'num\'].remove(1) # 修改父对象D1中的[1, 2, 3]列表子对象

print(\'原始数据:\',{\'user\': \'runoob\', \'num\': [1, 2, 3]}) # 原始数据
print(\'改后数据:\',D1) # 父子都修改过的
print(\'直接引用:\',D2) # 父子都变(直接引用)
print(\'浅拷贝:\',D3) # 父不变，子变(浅拷贝)
print(\'深拷贝:\',D4) # 父子都不变(深拷贝)

实例中 D2 其实是 D1 的赋值引用（别名），所以输出结果都是一致的；D3 是对D1的浅拷贝，父对象不会随D1修改而修改，子对象随D1的修改而修改；D4 是对D1的深拷贝，父对象和子对象都不会随D1修改而修改。

输出结果如下：
原始数据: {\'user\': \'runoob\', \'num\': [1, 2, 3]}
改后数据: {\'user\': \'root\', \'num\': [2, 3]}
赋值引用: {\'user\': \'root\', \'num\': [2, 3]}
浅拷贝: {\'user\': \'runoob\', \'num\': [2, 3]}
深拷贝: {\'user\': \'runoob\', \'num\': [1, 2, 3]}

fromkeys() 创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值

//描述
Python 字典 fromkeys() 函数用于创建一个新字典，以序列seq中元素做字典的键，value为字典所有键对应的初始值。
//语法
fromkeys()方法语法：
dict.fromkeys(seq[, value])
//参数
seq -- 字典键值列表。
value -- 可选参数, 设置键序列（seq）的值。
//返回值
该方法返回列表。
//实例
以下实例展示了 fromkeys()函数的使用方法：
#!/usr/bin/python3
seq = (\'name\', \'age\', \'sex\')

dict = dict.fromkeys(seq)
print ("新的字典为 : %s" %dict)
dict = dict.fromkeys(seq, 10)
print ("新的字典为 : %s" %dict)
以上实例输出结果为：
新的字典为 : {\'name\': None, \'age\': None, \'sex\': None}
新的字典为 : {\'name\': 10, \'age\': 10, \'sex\': 10}

View Code

python字典fromkeys()方法中的注意点（注意：fromkeys设置value参数时最好不用可变类型）

li = [1,2,3]
dic1 = dict.fromkeys(li)
dic2 = dict.fromkeys(li,[])
print(dic1)    # 打印结果{1: None, 2: None, 3: None}
print(dic2)    # 打印结果{1: [], 2: [], 3: []}
//此时为dic2中key为1的列表增加一个元素‘test’，如下：
dic2[1].append(\'test\')
print(dic2)      # 打印结果{1: [\'test\'], 2: [\'test\'], 3: [\'test\']}
//三个列表的值都被给改了，先打印下他们的内存地址
print("dic2[1]:{}\ndic2[2]:{}\ndic2[3]:{}".format(id(dic2[1]),id(dic2[2]),id(dic2[3])))
# dic2[1]:1714986428808
# dic2[2]:1714986428808
# dic2[3]:1714986428808
//so原来它的所有键都指向了同一个内存地址，这也就不难怪修改其中一个而引发联动了，因为本质上只有一个列表。因此，在字典中定义不同的列表不要用fromkeys方法，还是老老实实定义吧
dic2 =  {1: [], 2: [], 3: []}
print(id(dic2[1]))  # 1657985662344
print(id(dic2[2]))  # 1657986500680
print(id(dic2[3]))  # 1657986501960
dic2[1].append(\'test\')
print(dic2)
# {1: [\'test\'], 2: [], 3: []}
//使用循环来产生多key的字典：
dic2 = {}
for k in range(10):
dic2[k] = []
print(dic2)   # 打印结果{0: [], 1: [], 2: [], 3: [], 4: [], 5: [], 6: [], 7: [], 8: [], 9: []}
//tips: fromkeys方法会返回一个新的字典，对原字典无影响
dic1 = {1:2}
dic2 = dic1.fromkeys([1,2,3],\'test\')
print(dic1)    #  {1: 2}

get(key, default=None) 返回指定键的值，如果值不在字典中返回default值

//描述
Python 字典 get() 函数返回指定键的值，如果值不在字典中返回默认值。
//语法
get()方法语法：
dict.get(key, default=None)
//参数
key -- 字典中要查找的键。
default -- 如果指定键的值不存在时，返回该默认值值。
//返回值
返回指定键的值，如果值不在字典中返回自定义的默认值 。
实例
以下实例展示了 get()函数的使用方法：
#!/usr/bin/python3 
dict = {\'Name\': \'Runoob\', \'Age\': 27}
print ("Age 值为 : %s" %  dict.get(\'Age\'))
print ("Sex 值为 : %s" %  dict.get(\'Sex\', "NA"))
以上实例输出结果为:
Age 值为 : 27
Sex 值为 : NA

View Code

key in dict 如果键在字典dict里返回true，否则返回false

//描述
Python 字典 in 操作符用于判断键是否存在于字典中，如果键在字典 dict 里返回 true，否则返回 false。
而 not in 操作符刚好相反，如果键在字典 dict 里返回 false，否则返回 true。
//语法
in 操作符语法：
key in dict
//参数
key -- 要在字典中查找的键。
//返回值
如果键在字典里返回true，否则返回false。
//实例
以下实例展示了 in 操作符在字典中的使用方法：
实例(Python 3.0+)
#!/usr/bin/python3
dict = {\'Name\': \'Runoob\', \'Age\': 7}
# 检测键 Age 是否存在
if  \'Age\' in dict:
    print("键 Age 存在")
else :
    print("键 Age 不存在") 
# 检测键 Sex 是否存在
if  \'Sex\' in dict:
    print("键 Sex 存在")
else :
    print("键 Sex 不存在")
# not in
 
# 检测键 Age 是否存在
if  \'Age\' not in dict:
    print("键 Age 不存在")
else :
    print("键 Age 存在")
以上实例输出结果为：
键 Age 存在
键 Sex 不存在
键 Age 存在

View Code

items() 以列表返回可遍历的(键, 值) 元组数组

//描述
Python 字典 items() 方法以列表返回可遍历的(键, 值) 元组数组。
//语法
items()方法语法：
dict.items()
//参数
NA。
//返回值
返回可遍历的(键, 值) 元组数组。
//实例
以下实例展示了 items() 方法的使用方法：

#!/usr/bin/python3
dict = {\'Name\': \'Runoob\', \'Age\': 7}
print ("Value : %s" %  dict.items())
anjia=list(dict.items())    # 转换为列表
print(anjia)
以上实例输出结果为：
Value : dict_items([(\'Age\', 7), (\'Name\', \'Runoob\')])
[(\'Name\', \'Runoob\'), (\'Age\', 7)]

View Code

keys() 返回一个迭代器，可以使用 list() 来转换为列表

注意：python2中keys()、values()、items()是直接得到结果

d={\'k1\':111,\'k2\':2222}

# 在python2中
>>> d={\'k1\':111,\'k2\':2222}
>>> 
>>> d.keys()#6、循环
[\'k2\', \'k1\']
>>> d.values()
[2222, 111]
>>> d.items()
[(\'k2\', 2222), (\'k1\', 111)]
>>> dict(d.items())
{\'k2\': 2222, \'k1\': 111}
>>>

 

//描述
Python3 字典 keys() 方法返回一个迭代器，可以使用 list() 来转换为列表。
注意：Python2.x 是直接返回列表
//语法
keys()方法语法：
dict.keys()
//参数
NA。
//返回值
返回一个迭代器。
//实例
以下实例展示了 keys() 方法的使用方法：
dict = {\'Name\': \'Runoob\', \'Age\': 7}
dict.keys()
anjia=list(dict.keys())    # 转换为列表
print(anjia)

以上实例输出结果为：
[\'Age\', \'Name\']

View Code

setdefault(key, default=None) 和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default

//描述
Python 字典 setdefault() 方法和get()方法类似, 如果键不已经存在于字典中，将会添加键并将值设为默认值。
//语法
setdefault()方法语法：
dict.setdefault(key, default=None)
//参数
key -- 查找的键值。
default -- 键不存在时，设置的默认键值。
//返回值
如果 key 在 字典中，返回对应的值。如果不在字典中，则插入 key 及设置的默认值 default，并返回 default ，default 默认值为 None。
//实例
以下实例展示了 setdefault() 方法的使用方法：
#!/usr/bin/python3
dict = {\'Name\': \'Runoob\', \'Age\': 7}
print ("Age 键的值为 : %s" %  dict.setdefault(\'Age\', None))
#获取Sex 键的值，如果不存在则插入sex建并设置值为”man”
print ("Sex 键的值为 : %s" %  dict.setdefault(\'Sex\', "man"))   
print ("新字典为：", dict)
以上实例输出结果为：
Age 键的值为 : 7
Sex 键的值为 : man
新字典为： {\'Name\': \'Runoob\', \'Age\': 7, \'Sex\': \'man\'}

View Code

update(dict2) 把字典dict2的键/值对更新到dict里

//描述
Python 字典 update() 函数把字典参数 dict2 的 key/value(键/值) 对更新到字典 dict 里。
//语法
update() 方法语法：
dict.update(dict2)
//参数
dict2 -- 添加到指定字典dict里的字典。
//返回值
该方法没有任何返回值。
//实例
以下实例展示了 update()函数的使用方法：
实例(Python 2.0+)
#!/usr/bin/python3
dict = {\'Name\': \'Runoob\', \'Age\': 7}
dict2 = {\'Sex\': \'female\' }
dict.update(dict2)
print ("更新字典 dict : ", dict)
以上实例输出结果为：
更新字典 dict :  {\'Name\': \'Runoob\', \'Age\': 7, \'Sex\': \'female\'}

View Code

values() 返回一个迭代器，可以使用 list() 来转换为列表

//描述
Python 字典 values() 方法返回一个迭代器，可以使用 list() 来转换为列表，列表为字典中的所有值。
//语法
values()方法语法：
dict.values()
//参数
NA。
//返回值
返回迭代器。
//实例
以下实例展示了 values() 方法的使用方法：
#!/usr/bin/python3
dict = {\'Sex\': \'female\', \'Age\': 7, \'Name\': \'Zara\'}
print ("字典所有值为 : ",  list(dict.values()))
以上实例输出结果为：
字典所有值为 :  [\'female\', \'Zara\', 7]

View Code

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

实例：

移除dict中的元素(只能移除1个元素)：pop()，()内不能为空，要有key；若key不在dict内，需要主动给出需要返回的数据，否则报错；
A、key在dict_1内
dict_1 = {1:\'a\', 2:\'b\', 3:\'c\', 4:\'d\', 5:\'e\'}
a = dict_1.pop(2)
print(dict_1,   a)
-->{1:\'a\', 3:\'c\', 4:\'d\', 5:\'e\'}  b

 
B、key不在dict_1内：返回pop给定的数据
dict_1 = {1:\'a\', 2:\'b\', 3:\'c\', 4:\'d\', 5:\'e\'}
a = dict_1.pop(6,  [1, 2, 3, 4])
print(dict_1,   a)
-->{1:\'a\', 2:\'b\', 3:\'c\', 4:\'d\', 5:\'e\'}  [1, 2, 3, 4]

 

//描述
Python 字典 pop() 方法删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。
//语法
pop()方法语法：
pop(key[,default])
//参数
key: 要删除的键值
default: 如果没有 key，返回 default 值
//返回值
返回被删除的值。
//实例
以下实例展示了 pop() 方法的使用方法：
//代码
site= {\'name\': \'菜鸟教程\', \'alexa\': 10000, \'url\': \'www.runoob.com\'}
pop_obj=site.pop(\'name\')
print(pop_obj)
print(site)
//执行结果
菜鸟教程
{\'url\': \'www.runoob.com\', \'alexa\': 10000}

View Code

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

//描述
Python 字典 popitem() 方法随机返回并删除字典中的一对键和值(一般删除末尾对)。
如果字典已经为空，却调用了此方法，就报出KeyError异常。
//语法
popitem()方法语法：
popitem()
//参数
无
//返回值
返回一个键值对(key,value)形式。
//实例
以下实例展示了 popitem() 方法的使用方法：
#!/usr/bin/python3
site= {\'name\': \'菜鸟教程\', \'alexa\': 10000, \'url\': \'www.runoob.com\'}
pop_obj=site.popitem()
print(pop_obj) 
print(site)
输出结果为：
(\'url\', \'www.runoob.com\')
{\'name\': \'菜鸟教程\', \'alexa\': 10000}

View Code

for循环遍历字典

方法一
//遍历打印字典的key

dict = {
\'Name\': \'Runoob\',
\'Age\': 7,
\'Class\': \'First\',
}
for i in dict: #推荐使用
print(i)

或者：

dict = {
\'Name\': \'Runoob\',
\'Age\': 7,
\'Class\': \'First\',
}
for i in dict.keys():
print(i)

//遍历打印key和value

dict = {
\'Name\': \'Runoob\',
\'Age\': 7,
\'Class\': \'First\',
}
for i in dict: 
print(i,dict[i])

或者

dict = {
\'Name\': \'Runoob\',
\'Age\': 7,
\'Class\': \'First\',
}
for i in dict.keys():
print(i,dict[i])

方法二

dict = {
\'Name\': \'Runoob\',
\'Age\': 7,
\'Class\': \'First\',
}
for k,v in dict.items():
print(k,v)