1.1、创建字典

1.1.1、创建字典的几种方式

1.1.1.1、使用大括号创建

<code>dict001 = {'a': 1, 'b': 2, 'c': 3}

1.1.1.2、使用 dict() 函数创建

# 使用dict的构造方法，参数为关键字参数

dict001 = dict(a=1, b=2, c=3) # {'a': 1, 'b': 2, 'c': 3}

# 使用dict的构造方法，参数为嵌套元组的list，注意：传入的list结构是有要求的，list的每个元素都是一个两个元素的tuple

tuple_list =[("name", "jack"), ("age", 30)]

dict002 = dict(tuple_list) # {'name': 'jack', 'age': 30}

# 使用dict的构造方法，参数为 zip() 函数的返回值

dict003 = dict(zip("abc",[1,2,3])) # {'a': 1, 'b': 2, 'c': 3}

# 使用字典解析式

dict004 = {char : char* 2 for char in "ABCD"} # {'A': 'AA', 'B': 'BB', 'C': 'CC', 'D': 'DD'}

1.1.1.3、使用字典的 fromkeys() 函数初始化一个字典

# 说明：fromkeys()是dict类的一个staticmethod（静态方法）

seq = ('x', 'y', 'z')

# 创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值，默认为None，例如指定初始值为10

dict003 = dict.fromkeys(seq, 10)

1.1.1.4、创建一个有序的字典

在 Python 3.7 版本之前，字典是无序的，及输入dict001={'a':1,'b':2,'c':3}，打印的可能是dict001={'b':2,'c':3,'a':1}，但在 Python 3.7 及以上的版本中，保留了字典的插入顺序，及如何输入的就会如何输出，值得注意的是在进行字典比较时，比较的是里面的内容，内容一样，则返回True

dict001={'a':1,'b':2,'c':3}

dict002={'b':2,'c':3,'a':1}

print(dict001==dict002) # True

而真正创建有序的字典则需要用到collections模块中的OrderedDict，内容一样，但顺序不同，则会返回False。

from collections import OrderedDict

# 创建一个空的有序字典

my_ordered_dict = OrderedDict()

d001 = OrderedDict()

d001['a'] = 1

d001['b'] = 2

d001['c'] = 3

print(d001) # OrderedDict({'a': 1, 'b': 2, 'c': 3})

d002 = OrderedDict()

d002['a'] = 1

d002['c'] = 3

d002['b'] = 2

print(d002) # OrderedDict({'a': 1, 'c': 3, 'b': 2})

print(d001==d002) # False

d003 = OrderedDict()

d003['a'] = 1

d003['b'] = 2

d003['c'] = 3

print(d001==d003) # True

1.1.1.5、字典的浅拷贝和深拷贝

浅拷贝：

hold_list = [1,2,3]

old_dict = {"num":hold_list}

new_dict = old_dict.copy()

print(id(old_dict["num"])) # 2141756678856

print(id(new_dict["num"])) # 2141756678856

# 浅复制：old_dict与new_dict持有的是同一个hold_list对象，注意看id值

深拷贝：

from copy import deepcopy

hold_list = [1,2]

old_dict = {"num":hold_list}

new_dict = deepcopy(old_dict)

print(id(old_dict["num"])) # 2141787030152

print(id(new_dict["num"])) # 2141787012040

# 深复制：new_dict持有的也是一个新创建的host_list对象，注意看id值

1.2、字典的添加操作

1.2.1、使用中括号的方式

dict001 = {'杨过': '小龙女'}

# 说明：中括号指定key，赋值一个value，key不存在，则是添加元素（如果key已存在，则是修改key对应的value）

dict001['郭靖'] = '黄蓉'

print(dict001) # {'杨过': '小龙女', '郭靖': '黄蓉'}

1.2.2、使用update()方法

dict001 = {'杨过': '小龙女', 'country': 'china'}

# 参数为字典对象，使用dict的update方法，key不存在则是添加元素（key存在则是修改value）

dict001.update({'郭靖': '黄蓉'})

print(dict001) # {'杨过': '小龙女', 'country': 'china', '郭靖': '黄蓉'}

dict001.update({'country': '中国'})

print(dict001) # {'杨过': '小龙女', 'country': '中国', '郭靖': '黄蓉'}

# 参数为关键字参数，注意：关键字参数形式，key对象只能是字符串对象

dict001.update(temp="哈哈", help="呵呵")code>

print(dict001) # {'杨过': '小龙女', 'country': '中国', '郭靖': '黄蓉', 'temp': '哈哈', 'help': '呵呵'}

# 参数为字典解包方式

my_temp_dict = {'杨过': '陆无双', 'age':18}

dict001.update(**my_temp_dict) # 等同于：dict001.update(杨过='陆无双', age=18)

print(dict001) # {'杨过': '陆无双', 'country': '中国', '郭靖': '黄蓉', 'temp': '哈哈', 'help': '呵呵', 'age': 18}

1.3、字典的删除操作

1.3.1、使用 del 进行删除

dict001 = {"郭靖": "黄蓉", "张无忌": "赵敏", "杨过": "小龙女", "周伯通": "瑛姑"}

# 删除 "郭靖": "黄蓉" 这对元素，如果给的键不存在，会报错

del dict001['郭靖']

1.3.2、使用 pop() 方法进行删除

dict001 = {"郭靖": "黄蓉", "张无忌": "赵敏", "杨过": "小龙女", "周伯通": "瑛姑"}

# pop()删除不存在的键，会返回自定义的值 哈哈，如果没有给出该值，则会报错

variable001 = dict001.pop("郭靖")

print(variable001) # 黄蓉

variable002 = dict001.pop("张三", "哈哈")

print(variable002) # 哈哈

1.3.3、使用 popitem() 方法进行删除

dict001 = {"郭靖": "黄蓉", "张无忌": "赵敏", "杨过": "小龙女", "周伯通": "瑛姑"}

# 返回并删除字典中的最后一位键值对，如果字典已经为空，却调用了此方法，就报出 KeyError

variable = dict001.popitem() # ('周伯通', '瑛姑')

1.3.4、清空和删除字典

dict001 = {"郭靖": "黄蓉", "张无忌": "赵敏", "杨过": "小龙女", "周伯通": "瑛姑"}

dict001.clear() # 清空整个字典

del dict001 # 删除整个字典

1.4、字典的获取操作

1.4.1、通过KEY获取对应的值

dict001 = {"郭靖": "黄蓉", "张无忌": "赵敏", "杨过": "小龙女", "周伯通": "瑛姑"}

# 使用这种方式获取，如果key不存在则会报错

variable = dict001["郭靖"]

1.4.2、通过get()方式进行获取

dict001 = {"郭靖": "黄蓉", "张无忌": "赵敏", "杨过": "小龙女", "周伯通": "瑛姑"}

# 返回指定键对应的值,没有就返回 哈哈

variable = dict001.get("郭靖", "哈哈")

1.4.3、setdefault() 方法既可以获取又可以添加

dict001 = {"郭靖": "黄蓉", "张无忌": "赵敏", "杨过": "小龙女", "周伯通": "瑛姑"}

# 设置值，Key存在,返回Key对应的值，Key不存在，就添加到字典，并返回刚设置的值

variable = dict001.setdefault("apple", '苹果')

1.4.4、获取所有的Key

dict001 = {"郭靖": "黄蓉", "张无忌": "赵敏", "杨过": "小龙女", "周伯通": "瑛姑"}

# 返回迭代器 dict_keys(['郭靖', '张无忌', '杨过', '周伯通'])

variable = dict001.keys()

# 可以用list直接转换成列表 ['郭靖', '张无忌', '杨过', '周伯通']

keys = list(variable)

1.4.5、获取所有的Value

dict001 = {"郭靖": "黄蓉", "张无忌": "赵敏", "杨过": "小龙女", "周伯通": "瑛姑"}

# 返回迭代器 dict_values(['黄蓉', '赵敏', '小龙女', '瑛姑'])

variable = dict001.values()

# 可以用list直接转换成列表 ['黄蓉', '赵敏', '小龙女', '瑛姑']

values = list(variable)

1.4.6、获取所有的键值对列表

dict001 = {"郭靖": "黄蓉", "张无忌": "赵敏", "杨过": "小龙女", "周伯通": "瑛姑"}

# 返回迭代器 dict_items([('郭靖', '黄蓉'), ('张无忌', '赵敏'), ('杨过', '小龙女'), ('周伯通', '瑛姑')])

variable = dict001.items()

# 可以用list直接转换成列表 [('郭靖', '黄蓉'), ('张无忌', '赵敏'), ('杨过', '小龙女'), ('周伯通', '瑛姑')]

keyValue = list(variable)

1.4.7、批量获取指定键对应的值

需求：给出一个key列表，获取对应的值

1.4.7.1、使用高阶函数的方式（推荐）

dict001 = {"郭靖": "黄蓉", "张无忌": "赵敏", "杨过": "小龙女", "周伯通": "瑛姑"}

key_list = ["杨过", "郭靖"]

values = list(map(dict001.get, key_list))

1.4.7.2、使用列表推导式的方式

dict001 = {"郭靖": "黄蓉", "张无忌": "赵敏", "杨过": "小龙女", "周伯通": "瑛姑"}

key_list = ["杨过", "郭靖"]

values = [dict001.get(key) for key in key_list]

1.5、字典的合并和遍历

1.5.1、合并字典

在 Python 2 中，使用 update（）合并两个字典，Python 3 变得更加简单。下面脚本中，两个字典被合并。在相交（key相同）的情况下，使用第二个字典中的值。

1.5.1.1、pyton3中合并字典的方式（推荐）

dict001 = {'apple':9,'banana':6}

dict002 = {'banana':4,'orange':8}

dict003 = {**dict001,**dict002}

print(dict003) # 输出：{'apple':9,'banana':4,'orange':8}

1.5.1.2、借助字典的 dict(**d1, **d2) 方法合并(推荐)

dict001 = {'a': 1, 'b': 2, 'c': 3}

dict002 = {'aa': 11, 'bb': 22, 'cc': 33}

print(dict(**dict001, **dict002)) # 输出：{'a': 1, 'aa': 11, 'c': 3, 'b': 2, 'bb': 22, 'cc': 33}

1.5.1.3、借助字典的update()方法合并

dict001 = {'a': 1, 'b': 2, 'c': 3}

dict002 = {'aa': 11, 'bb': 22, 'cc': 33, 'a': 100}

dict003 = {}

dict003.update(dict001)

dict003.update(dict002)

print(dict003) # 输出：{'a': 100, 'b': 2, 'c': 3, 'aa': 11, 'bb': 22, 'cc': 33}

1.5.1.4、借助字典的常规处理方法合并（不推荐）

dict001 = {'a': 1, 'b': 2, 'c': 3}

dict002 = {'aa': 11, 'bb': 22, 'cc': 33}

dict002 = {}

for k, v in dict001.items():

dict003[k] = v

for k, v in dict002.items():

dict003[k] = v

print(dict003) # 输出：{'a': 1, 'aa': 11, 'c': 3, 'b': 2, 'bb': 22, 'cc': 33}

1.5.2、遍历字典

1.5.2.1、遍历所有的键

dict001 = {"郭靖": "黄蓉", "张无忌": "赵敏", "杨过": "小龙女", "周伯通": "瑛姑"}

# 注意：直接遍历字典就是遍历所有的键

for key in dict001:

print(key)

1.5.2.2、遍历所有的值

dict001 = {"郭靖": "黄蓉", "张无忌": "赵敏", "杨过": "小龙女", "周伯通": "瑛姑"}

for value in dict001.values():

print(value)

1.5.2.3、遍历所有的键值对儿

dict001 = {"郭靖": "黄蓉", "张无忌": "赵敏", "杨过": "小龙女", "周伯通": "瑛姑"}

# 遍历键和值：

for key, value in dict001.items():

print(key, value)

1.6、字典排序

在Python中，字典本身是无序的，直到Python3.7版本，字典在迭代时会保持插入顺序。如果你需要根据键（key）或值（value）对字典中的项进行排序，可以使用内置的sorted()函数，它返回一个排序后的列表。

1.6.1、按照字典中的键给字典排序

dict001 = {'banana': 3, 'apple': 4, 'pear': 1, 'orange': 2}

# reverse=True表示降序，默认False，升序排序，注意：这会得到一个新字典，原字典dict001没有改变

variable = dict(sorted(dict001.items(), key=lambda x: x[0], reverse=True))

1.6.2、按照字典中的值给字典排序

dict001 = {'banana': 3, 'apple': 4, 'pear': 1, 'orange': 2}

# reverse=True表示降序，默认False，升序排序，注意：这会得到一个新字典，原字典dict001没有改变

variable = dict(sorted(dict001.items(), key=lambda x: x[1], reverse=True))

1.6.3、使用 OrderedDict() 进行排序

from collections import OrderedDict

# 根据值排序并创建OrderedDict

sorted_dict = OrderedDict(sorted(my_dict.items(), key=lambda item: item[1]))

1.7、字典的常见需求

1.7.1、字典格式的字符串转为字典

import ast

# 注意：user实际上是一个字符串

user = '{"name" : "john", "gender" : "male", "age": 28}'

# 使用 ast 模块的literal_eval() 方法可以将其转变为字典对象

user_dict1 = ast.literal_eval(user)

1.7.2、将字典转成json字符串

import json

dict001 = {"name" : "john", "gender" : "male", "age": 28}

# dumps用于将字典转化成json格式的字符串，dumps这一过程又被称为序列化。

variable = json.dumps(dict001, indent=4, sort_keys=True)

dump()函数用于将一个python对象（需要是json可序列化的）保存到相应的json文件中，dump()没有返回值。

import json

dict001 = {"name" : "john", "gender" : "male", "age": 28}

with open("test.json", "w") as f:

json.dump(dict001, f)

1.7.3、字典求交集

需求：把两个字典中相同的键值对儿拿出来组成一个新字典

dict001 = {"郭靖": "黄蓉", "杨过": "小龙女", "tom": "jack", "光头强": "熊大"}

dict002 = {"郭靖": "黄蓉", "杨过": "小龙女", "Bob": "ros", "光头强": "熊二"}

variable = {k: dict001[k] for k in dict001 if k in dict002 and dict001[k] == dict002[k]}

1.7.4、键同值不同

需求：找出字典1中和字典2中键相同但值不同，或者字典1中存在但字典2中不存在的键值对

dict001 = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'f': 8}

dict002 = {'a': 1, 'b': 2, 'c': 4, 'd': 5, 'e': 6}

def compare_dict(dict001, dict002):

"""

找出字典1中和字典2中键相同但值不同，或者字典1中存在但字典2中不存在的键值对

"""

res = {}

for alike_key in dict001:

z = dict001.get(alike_key) == dict002.get(alike_key)

if not z:

print('相同的键:', alike_key)

print('字典1的值：', dict001.get(alike_key), '字典2的值：', dict002.get(alike_key))

k1 = "dict001_{}".format(str(alike_key))

k2 = "dict002_{}".format(str(alike_key))

res[k1] = dict001.get(alike_key)

res[k2] = dict002.get(alike_key)

return res