dict1={'abc':456}
dict2={'abc':123,96.3:37}
print(dict1)
print(dict2)
dict3=dict()#创建空字典
dict4=dict(a='a23',b='b45',c='c78')#传入关键字
dict5=dict(zip(['one','two','three'],[1,2,3])) #映射函数
dict6=dict([('one',1),('two',2),('three',3)])#可迭代对象方式构建字典
print(dict3)
print(dict4)
print(dict5)
print(dict6)

访问字典的值

把相应的键放入熟悉的方括弧，如下实例:

dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
print(dict['Name'])
print(dict['Age'])

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

print(dict['Alice'])

实现遍历访问

dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
for key in dict:
    print(f'key={key},value={dict[key]}')

修改字典

更新和添加新的键值对

dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
dict['Name']='Jennifer' #修改
dict['School']='ABCuniversity' #添加
print(dict)

删除字典元素

能删单一的元素也能清空字典，清空只需一项操作。

显示删除一个字典用del命令，如下实例：

dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
del dict['Name'] #删除键是’Name‘的条目
print(dict)
dict.clear()#清空字典的所有条目
print(dict)
del dict

映射类型操作符

标准类型操作符

>,<,<=,>=不支持dict与dict进行比较，==,!=可以判断是否每个key对应的每个value都相等。

映射类型操作符

字典的键查找操作符（[]）

键查找操作符是唯一仅用于字典类型的操作符，它和序列类型里单一元素的切片（slice）操作符很相象。对序列类型来说，用索引做唯一参数或下标（subscript）以获取一个序列中某个元素的值。对字典类型来说，是用键查询（字典中的元素），所以键是参数（ argument），而不是一个索引（index）。键查找操作符既可以用于给字典赋值，也可以用于从字典中取值：

d[k]=v 通过键k，给字典中某元素赋值

d[k] 通过键k，查询字典中某元素的值。

（键）成员关系操作（in，not in）

用in 和not in 可以检查某个键是否存在于字典中。

dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
if 'Name'in dict:
    print(True)
if 'Namelala' not in dict:
    print(True)

映射类型的内建函数和工厂函数

标准类型函数 type（）str（） sorted（）

对一个字典调用 type工厂方法，会返回字典类型，“< type 'dict>”。调用str()工厂方法将返回该字典的字符串表示形式。

print(type(dict))
print(str(dict))

分类sorted(iterable,key,reverse)

可对键、值、键值对排序

dict = {1:2,3:4,5:6}
key=dict.keys()
print(sorted(key))
value=dict.values()
print(sorted(value))
items=dict.items()
print(sorted(items))

映射类型相关函数 dict() len（） hash（）

dict（）工厂函数被用来创建字典。如果不提供参数，会生成空字典。当容器类型对象作为一个参数传递给方法dict（）时很有意思。如果参数是可以迭代的，即一个序列，或是一个迭代器，或是一个支持迭代的对象，那每个可迭代的元素必须成对出现。在每个值对中，第1个元素是字典的键，第2个元素是字典中的值。

dict3=dict()#创建空字典
dict4=dict(a='a23',b='b45',c='c78')#传入关键字
dict5=dict(zip(['one','two','three'],[1,2,3])) #映射函数
dict6=dict([('one',1),('two',2),('three',3)])#可迭代对象方式构建字典
dict7=dict([('xy'[i-1],i)for i in range(1,3)])#可迭代对象方式构建字典
print(dict3)
print(dict4)
print(dict5)
print(dict6)
print(dict7)

对字典调用len（）函数，返回字典中键值对的数目

内建函数 hash（）本身并不是为字典设计的方法，但它可以判断某个对象是否可以做一个字典的键。

将一个对象作为参数传递给 hash（），会返回这个对象的哈希值。只有这个对象是可哈希的，才可作为字典的键（函数的返回值是整型，不产生错误或异常）。

如果用比较操作符来比较两个数值，发现它们是相等的，那么即使二者的数据类型不同，它们也会得到相同的哈希值。

如果非可哈希类型作为参数传递给 hash（）方法，会产生 Type Error错误（因此，如果使用这样的对象作为键给字典赋值时会出错）。

hash([])

hash('acb')

映射类型内建方法

字典的类型转换 dict()和fromkeys()

转换1: dict（）工厂函数被用来创建字典。如果不提供参数，会生成空字典。当容器类型对象作为一个参数传递给方法dict（）时很有意思。如果参数是可以迭代的，即一个序列，或是一个迭代器，或是一个支持迭代的对象，那每个可迭代的元素必须成对出现。在每个值对中，第1个元素是字典的键，第2个元素是字典中的值。

dict3=dict()#创建空字典
dict4=dict(a='a23',b='b45',c='c78')#传入关键字
dict5=dict(zip(['one','two','three'],[1,2,3])) #映射函数
dict6=dict([('one',1),('two',2),('three',3)])#可迭代对象方式构建字典
dict7=dict([('xy'[i-1],i)for i in range(1,3)])#可迭代对象方式构建字典
print(dict3)
print(dict4)
print(dict5)
print(dict6)
print(dict7)

转换2：fromkeys会从元组中取出每个值当做key，然后与None组成key:value放到字典中

print({}.fromkeys(('name','age','sex'),None))

清空一个字典clear()

可以清空一个字典，还有一种方式是直接给变量赋值为一个空的字典。

直接给变量名赋值为一个空字典并没有改变原来的字典，只是重新分配了一个新的字典给a。

a={'b':1,'c':2}
e=a
print(e)
a={}
print(a)
print(e)

a={'b':1,'c':2}
e=a
print(e)
a.clear() #清空的是字典本身
print(a)
print(e)

得到一个键对应的值 get(key) pop()

get(key[,default]) 获得给定键的值，当键不存在时返回None。

dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
print(dict.get("Name"))
print(dict.get('School'))

弹出给定键的值pop()

如果字典中key关键字，删除并返回dict[key],如果键不存在，报错KeyError。

setdefault(key,default) 检查字典中是否存在某键。存在则返回，不存在添加且设置默认值

当字典中存在给定的键时，返回该键对应的值；如果该键不存在，则添加给定的键，对应值为None。

字典连接函数 update（）

update函数可以将两个字典连接起来，但是如果第二个字典和第一个字典有相同键，那么第一个字典会被更新。

dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}

dict2={'sex':'male','School':'abcuniversity2','Class':3}
dict.update(dict2)
print(dict)

复制字典 copy（）

copy方法返回一个字典的副本，浅拷贝。

dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
dict2=dict.copy()
print(dict2)

键值对视图 items（）

dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
item=dict.items()
print(type(item))
print(item)

键视图 keys（）

本身类型是‘dict_keys’，按需要强制转化成列表等数据结构

dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
key=dict.keys()
print(type(key))
print(key)

值视图 values（）

dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
value=dict.values()
print(type(value))
print(value)

前面三个返回的都是视图对象。该对象提供字典条目的一个动态视图，这意味着当字典改变时，视图也会相应改变。大多数情况下我们希望得到的是列表，可以使用list()进行转换，对于keys()来说，list(d)与list(d.keys())是一样的。

dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}
value=dict.values()
print(value)
dict['Name']='YuBo'
print(type(value))
print(value)

字典的键的特点

字典中的值没有任何限制。他们可以是任意Python对象，即从标准对象到用户自定义对象皆可。但是字典的键是有类型限制的。

不允许一个键对应多个值

每个键只能对应一个项。也就是说，一键对应多个值是不允许的（像列表、元组和其他字典这样的容器对象是可以的）。当有键发生冲突（即字典键重复赋值），取最后（最近）的赋值。

键必须是可哈希的

为什么键必须是可哈希的？解释器调用哈希函数，根据字典中键的值来计算存储你的数据的位置。如果键是可变对象，它的值可改变。如果键发生变化，哈希函数会映像到不同的地址来存储数据。如果这样的情况发生，哈希函数就不可能可靠地存储或获取相关的数据。选择可哈希的键的原因就是因为它们的值不能改变。

字典推导式

{key: value for (key, value) in iterable}

d1 = {key: value for (key, value) in zip('0123456789', range(10))}
d2 = dict(zip('0123456789', range(10)))
print(d1)
print(d2)
d3={key:value for (key,value) in ((1,2),(3,4),(5,6))}
# d4={key:value for (key,value) in 1=2,3=4,5=6} #不可以
d4=dict(a='a23',b='b45',c='c78')#传入关键字
d5=dict(zip(['one','two','three'],[1,2,3])) #映射函数
print(d3)
print(d4)
print(d5)

更多Python框架梳理，请参考：【Python学习】Python最全总结

有问题请下方评论，转载请注明出处，并附有原文链接，谢谢！如有侵权，请及时联系。

以上是关于字典的操作总结（基本方法操作符内建函数字典特点字典推导式）的主要内容，如果未能解决你的问题，请参考以下文章

字典方法

Python字典创建、基本操作以及常用方法

python--dict方法总结

Python 字典常用操作

字符串，列表，元组，字典，集合，序列通用操作

字典常用的方法（内建函数）