字典

1.1、创建字典

1.1.1、创建字典的几种方式

1.1.1.1、使用大括号创建

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="呵呵")
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