瓜瓜头条

字典

2024-09-27 16:11 由 【1758872】的博客 发表于 #后端开发

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