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

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'}

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

# !/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}

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

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 存在

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)]

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']

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'}

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'}

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]

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}

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}

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)