首页 > 其他分享 >字典

字典

时间：2024-09-27 16:12:35浏览次数：9  
标签：dict001 郭靖 dict key 杨过 字典

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

 

标签：dict001,郭靖,dict,key,杨过,字典
From： https://www.cnblogs.com/crazywh/p/18435974

相关文章

  • 利用反射扫描枚举生成数据字典数据
    在开发过程中经常遇到既需要维护枚举来完成各种条件判断，又需要维护数据字典供前端使用，维护数据字典的另一个用处是可以修改数据字典的label而无需调整代码，但是这种两边维护的方式非常浪费人力资源，甚至有时部署程序忘了维护数据字典导致线上环境出现无法正常显示等问题。为解......
  • 05 in 判断是否包含查找内容示例 包含 字符串 列表 元组 字典
    1、strv="Python全栈21期"if"全栈"inv:print('含敏感字符')2、list/tuplev=['alex','oldboy','藏老四','利奇航']if"利奇航"inv:print('含敏感')3、dictv={'k1......
  • 05 字典内存分配
    data_list=[]foriinrange(10):data={}data['user']=idata_list.append(data)print(data_list)#每个字典都不一样字典，列表内存指向图data={}foriinrange(10):data['user']=iprint(data)内存占用图......
  • 16 字典 独有功能
    帮助用户去表示一个事物的信息（事物是有多个属性）。存储数据时，需要健值时，使用字典进行存储info={"name":'刘伟达','age':18,'gender':'男','hobby':'同桌'}#键值#请输出：我今天点%s,他的年龄是%s,性别是%s，他喜欢他的%s;基本格式data={键:值,键:值,键:值,键:值,键:......
  • 18 字典 练习题
    练习题#!/usr/bin/envpython#-*-coding:utf-8-*-""""""#1.请获取"刘伟达""""info={"name":'刘伟达','age':18,'gender':'男','hobby':'同桌'}......
  • 17 字典公共功能
    1、leninfo={"name":'刘伟达','age':18,'gender':'男','hobby':'同桌'}print(len(info))2、索引info={"name":'刘伟达','age':18,'gender':'男','......
  • Go从入门到放弃之map(字典)
    字典声明和初始化Go语言中提供的映射关系容器为map，map也是个无序集合，底层不会按照元素添加顺序维护元素的存储顺序Go语言中 map的定义语法如下：KeyType:表示键的类型。ValueType:表示键对应的值的类型。map[KeyType]ValueTypemap类型的变量默认初始值为nil，需要使用make()函数来......
  • 解读MySQL8.0数据字典重构源码
    摘要：本文对社区MySQL5.7到8.0演进过程中数据字典DD的重构（缓存，持久化），AtomicDDL的关键实现进行了分析。本文分享自华为云社区《【华为云MySQL技术专栏】MySQL8数据字典重构源码解读》，作者：GaussDB数据库1.背景介绍在MySQL5.7版本的使用实践过程中，我们很容易遇到DDL崩溃后导致数......
  • 对于 pytest，如何为每个模块生成和加载字典
    我需要一种方法来生成一个字典，其中包含给定目录中每个pytest模块/文件的唯一路径。在运行任何测试来定义文件路径之前，它需要可访问：TEST_DIRS={}path1=TEST_DIRS['path']path2=TEST_DIRS['input']deftest_something():target=path1/'input_file'.........
  • 3170. 删除星号以后字典序最小的字符串
    题目链接3170.删除星号以后字典序最小的字符串思路堆栈&位运算题解链接三种写法：26个栈+位运算优化（Python/Java/C++/Go）关键点1.用堆栈跟踪各个字母出现的位置2.用位运算跟踪当前最小字母（lowbit技巧）时间复杂度朴素做法：\(O(n\vert\Sigma\vert)\)位运算......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99