python之Dict操作(下)

最新推荐文章于 2023-02-22 23:10:30 发布
最新推荐文章于 2023-02-22 23:10:30 发布
阅读量360 收藏 4
点赞数 1
文章标签： python dict 字典
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45080696/article/details/102609567
版权

文章目录

python之Dict操作(下)

10. Dict排序

1) 根据key对字典排序

根据key，对字典进行排序
推荐写法: 使用Python3的标准库，内置函数：sorted(iterable[, key=None[, reverse=False])，key和reverse是可选参数

  • 返回一个排序列表
  • iterable用于指定一个可迭代对象，这里是一个字典实例
  • key用于指定排序规则，默认是None，语法是key=lambda elem:xxx
  • reverse用于指定排序方向，默认是升序，语法是reverse=False/True
dict1 = {"a": 3, "c": 1, "b": 2}

# item指代(键，值)元组，item[0]是键, item[1]是值
# 正序
dict_sorted = sorted(dict1.items(), key=lambda item: item[0])
print(dict_sorted)  # [('a', 3), ('b', 2), ('c', 1)]

# 逆序
dict_sorted_rev = sorted(dict1.items(), key=lambda item: item[0], reverse=True)
print(dict_sorted_rev)  # [('c', 1), ('b', 2), ('a', 3)]

# ------
# 注意：sorted(dict1)默认是对key排序，而不是对整个字典
sorted1 = sorted(dict1)
print(sorted1)  # ['a', 'b', 'c']
2) 根据key对value排序

根据字典的键，对值进行排序
推荐写法

  • 先使用内置函数sorted，根据key对字典排序
  • 再使用推导式，获取value列表
  • 关于sorted函数的用法，参看章节“根据key对字典排序”
dict1 = {"a": 3, "c": 1, "b": 2}

list1 = sorted(dict1.items(), key=lambda item: item[0])
print(list1)  # 根据key对字典排序 [('a', 3), ('b', 2), ('c', 1)]

list2 = [value for key, value in list1]
print(list2)  # [3, 2, 1]

推荐写法

  • 先使用内置函数sorted，对字典的键列表排序
  • 再使用推导式，获取key对应的value
dict1 = {"a": 3, "c": 1, "b": 2}
keys = sorted(dict1.keys())
list1 = [dict1[k] for k in keys]
print(list1)  # [3, 2, 1]

推荐写法

  • 先使用内置函数sorted，对字典的键列表排序
  • 再使用内置函数map，获取key对应的value
  • 由于Python3.x版本中，map函数的返回一个迭代器（Python2.x版本中map返回一个列表），需要使用内置类list(iterable)进行转换
dict1 = {"a": 3, "c": 1, "b": 2}
keys = sorted(dict1.keys())
list1 = list(map(dict1.get, keys))
print(list1)  # [3, 2, 1]
3) 根据value对字典排序

根据value，对字典进行排序
推荐写法: 使用Python3的标准库，内置函数：sorted(iterable[, key=None[, reverse=False])，key和reverse是可选参数

  • 用法同上
dict1 = {"a": 3, "c": 1, "b": 2}

# item指代(键，值)元组，item[0]是键, item[1]是值
# 正序
dict_sorted = sorted(dict1.items(), key=lambda item: item[1])
print(dict_sorted)  # [('c', 1), ('b', 2), ('a', 3)]

# 逆序
dict_sorted_rev = sorted(dict1.items(), key=lambda item: item[1], reverse=True)
print(dict_sorted_rev)  # [('a', 3), ('b', 2), ('c', 1)]
4) 根据某个key对应的value对字典列表排序

根据字典中某个key对应的value，对字典列表进行排序
*推荐写法: 使用Python3的标准库，operator模块的类：itemgetter(keys)

  • 需要导入operator模块的itemgetter
  • keys用于指定键，接受多个key参数，多个参数使用逗号”,“隔开
from operator import itemgetter

stu = [
	{"id": 3, "name": "Tom", "score": 82},
	{"id": 2, "name": "Jerry", "score": 67},
	{"id": 1, "name": "Pig", "score": 82},
	{"id": 4, "name": "Dog", "score": 98},
]
# 根据key"score"对应的value 对stu正序排序
'''
[{'id': 2, 'name': 'Jerry', 'score': 67},
{'id': 3, 'name': 'Tom', 'score': 82},
{'id': 1, 'name': 'Pig', 'score': 82},
{'id': 4, 'name': 'Dog', 'score': 98}]
'''

sorted_by_score = sorted(stu, key=itemgetter("score"))
print(sorted_by_score)

# 根据key"score"对应的value 对stu逆序排序
'''
[{'id': 4, 'name': 'Dog', 'score': 98},
{'id': 3, 'name': 'Tom', 'score': 82},
{'id': 1, 'name': 'Pig', 'score': 82},
{'id': 2, 'name': 'Jerry', 'score': 67}]
'''
sorted_by_score_rev = sorted(stu, key=itemgetter("score"), reverse=True)
print(sorted_by_score_rev)

# 根据key"score"和"id" 对stu正序排序(先根据"score"排序，"score"相同的情况下根据"id"排序)
'''
[{'id': 2, 'name': 'Jerry', 'score': 67},
{'id': 1, 'name': 'Pig', 'score': 82},
{'id': 3, 'name': 'Tom', 'score': 82},
{'id': 4, 'name': 'Dog', 'score': 98}]
'''
rows_by_score_id = sorted(stu, key=itemgetter("score", "id"))
print(rows_by_score_id)

*推荐写法: 使用Python3的标准库，内置函数：sorted(iterable, , key=None, reverse=False)

  • 接受多个key参数，多个参数使用逗号”,“隔开
stu = [
	{"id": 3, "name": "Tom", "score": 82},
	{"id": 2, "name": "Jerry", "score": 67},
	{"id": 1, "name": "Pig", "score": 82},
	{"id": 4, "name": "Dog", "score": 98},
]
# 根据key"score"对应的value 对stu正序排序
'''
[{'id': 2, 'name': 'Jerry', 'score': 67},
{'id': 3, 'name': 'Tom', 'score': 82},
{'id': 1, 'name': 'Pig', 'score': 82},
{'id': 4, 'name': 'Dog', 'score': 98}]
'''
sorted_by_score = sorted(stu, key=lambda item: item["score"])
print(sorted_by_score)
# 根据key"score"对应的value 对stu逆序排序
'''
[{'id': 4, 'name': 'Dog', 'score': 98},
{'id': 3, 'name': 'Tom', 'score': 82},
{'id': 1, 'name': 'Pig', 'score': 82},
{'id': 2, 'name': 'Jerry', 'score': 67}]
'''
sorted_by_score_rev = sorted(stu, key=lambda item: item["score"], reverse=True)
print(sorted_by_score_rev)

# 根据key"score"和"id" 对stu正序排序(先根据"score"排序，"score"相同的情况下根据"id"排序)
'''
[{'id': 2, 'name': 'Jerry', 'score': 67},
{'id': 1, 'name': 'Pig', 'score': 82},
{'id': 3, 'name': 'Tom', 'score': 82},
{'id': 4, 'name': 'Dog', 'score': 98}]
'''
rows_by_score_id = sorted(stu, key=lambda item: (item["score"], item["id"]))
print(rows_by_score_id)

11. Dict运算

基于键值视图对象也支持Set运算(比如集合的并、交、差运算)这一重要特性，进行求并集、交集、差集、对称差集的字典间运算

1) 合并

合并两个字典，键是唯一的，值可以是任意的
推荐写法: 使用Python3的标准库，dict类内置函数：update(other)，other指代一个字典对象

  • 修改当前字典，添加新的元素或Dict到当前字典中
  • 若key已存在，则会修改相应的值，若key不存在，则添加元素
a = {"one": 1, "two": 2, "three": 3}
b = {"one": 111, "three": 3, "four": 4}

a.update(b)
print(a)  # key"one"的值被修改 {'one': 111, 'two': 2, 'three': 3, 'four': 4}

一般写法: 使用运算符”|“

  • 返回一个新Dict
  • 运算符”|“的作用对象是两个字典的键值对列表视图，而不是字典实例
  • 若出现重复键，则第一个字典key对应的值会被使用，即它的值不会被修改
  • 若原字典做了更新，不会影响新合并的字典
  • 若新合并的字典更新了，这种改变总是影响第一个字典
a = {"one": 1, "two": 2, "three": 3}
b = {"one": 111, "three": 3, "four": 4}

c = dict(a.items() | b.items())
print(c)  # key"one"的值没有被修改 {'four': 4, 'one': 1, 'three': 3, 'two': 2}

a.clear()
print(c)  # 原字典改变 不会影响新合并的字典 {'four': 4, 'one': 1, 'three': 3, 'two': 2}

c.clear()
print(a)  # 新合并的字典改变 影响第一个字典 {}
print(b)  # 新合并的字典改变 不会影响第二个字典 {'one': 111, 'three': 3, 'four': 4}

一般写法: 使用Python3的标准库，collections模块的类：ChainMap(*maps)

  • 需要导入collections模块的ChainMap
  • 返回一个新Dict
  • 若出现重复键，则第一个字典key对应的值会被使用，即它的值不会被修改
  • 若原字典做了更新，会影响新合并的字典
  • 若新合并的字典更新了，这种改变总是影响第一个字典
from collections import ChainMap

a = {"one": 1, "two": 2, "three": 3}
b = {"one": 111, "three": 3, "four": 4}

c = ChainMap(a, b)
print(c)  # ChainMap({'one': 1, 'two': 2, 'three': 3}, {'one': 111, 'three': 3, 'four': 4})
print(c["one"])  # 1 (from a)
print(c["two"])  # 2 (from a)
print(c["three"])  # 3 (from a)
print(c["four"])  # 4 (from b)

a.clear()
print(c)  # ChainMap({}, {'one': 111, 'three': 3, 'four': 4})
print(c["two"])  # 原字典改变 影响新合并的字典 抛出KeyError: 'two'

c.clear()
print(a)  # 新合并的字典改变 影响第一个字典 {}
print(b)  # 新合并的字典改变 不会影响第二个字典 {'one': 111, 'three': 3, 'four': 4}
2) 交集

从第一个字典中移除与第二个字典不相同的键值对
一般写法: 使用运算符”&“

  • 返回一个新Dict
  • 运算符”&“的作用对象是两个字典的键值对列表视图，而不是字典实例
  • 从第一个字典中移除与第二个字典不相同的键值对
  • 若原字典做了更新，不会影响新字典
  • 若新字典更新了，这种改变总是影响第一个字典
a = {"one": 1, "two": 2, "three": 3}
b = {"one": 111, "three": 3, "four": 4}

c = dict(a.items() & b.items())
print(c)  # {'three': 3}

a.clear()
print(c)  # 原字典改变 不会影响新字典 {'three': 3}

c.clear()
print(a)  # 新字典改变 影响第一个字典 {}
print(b)  # 新字典改变 不会影响第二个字典 {'one': 111, 'three': 3, 'four': 4}
3) 差集

从第一个字典中移除与第二个字典相同的键值对
一般写法: 使用运算符”-“

  • 返回一个新Dict
  • 运算符”-“的作用对象是两个字典的键值对列表视图，而不是字典实例
  • 从第一个字典中移除与第二个字典相同的键值对
  • 若原字典做了更新，不会影响新字典
  • 若新字典更新了，这种改变总是影响第一个字典
a = {"one": 1, "two": 2, "three": 3}
b = {"one": 111, "three": 3, "four": 4}

c = dict(a.items() - b.items())
print(c)  # {'two': 2, 'one': 1}

a.clear()
print(c)  # 原字典改变 不会影响新字典 {'two': 2, 'one': 1}

c.clear()
print(a)  # 新字典改变 影响第一个字典 {}
print(b)  # 新字典改变 不会影响第二个字典 {'one': 111, 'three': 3, 'four': 4}
4) 对称差集

从第一个字典中移除与第二个字典相同的键值对，并将第二个字典中特有的键值对插入到当前字典中
一般写法: 使用运算符”^“

  • 返回一个新Dict
  • 运算符”^“的作用对象是两个字典的键值对列表视图，而不是字典实例
  • 从第一个字典中移除与第二个字典相同的键值对，并将第二个字典中特有的键值对插入到当前字典中
  • 若原字典做了更新，不会影响新字典
  • 若新字典更新了，这种改变总是影响第一个字典
a = {"one": 1, "two": 2, "three": 3}
b = {"one": 111, "three": 3, "four": 4}

c = dict(a.items() ^ b.items())
print(c)  # {'four': 4, 'one': 1, 'two': 2}

a.clear()
print(c)  # 原字典改变 不会影响新字典 {'four': 4, 'one': 1, 'two': 2}

c.clear()
print(a)  # 新字典改变 影响第一个字典 {}
print(b)  # 新字典改变 不会影响第二个字典 {'one': 111, 'three': 3, 'four': 4}
5) 补集

A相对于B中的补集是指B中移除与A相同的键值对的字典
推荐写法: 使用运算符“-”

  • 返回一个新Dict，不会修改当前Dict
a = {"one": 1, "two": 2, "three": 3}
b = {"one": 1, "two": 2}
c = {"one": 111, "two": 2}

# b相对于a的绝对补集(a包含b)
b_a = a.items() - b.items()
print(b_a)  # {('three', 3)}

# b相对于c的相对补集(c和b有交集但是c不包含b)
b_c = c.items() - b.items()
print(b_c)  # {('one', 111)}
6) 过滤请求参数
keys_to_remove = ("param0", "param1", "param2", "uuid")
list(map(lambda x: functools.partial(request_body.pop, x, None)(), keys_to_remove))
for key in list(request_body.keys()):
    if request_body.get(key) == 0:
        continue
    if not request_body.get(key):
        request_body.pop(key)
我行于野
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
python-->(set /dict)交集 差集 并集 补集(功能用来做交差并补的)
weixin_30823227的博客
04-25 267
# ### 集合 作用:交集 差集 并集 补集(功能用来做交差并补的) '''特征:自动去重 无序''' #定义一个空集合 setvar = set() #set()强制转换成一个空集合的数据类型 print(setvar,type(setvar)) setvar = {"张学友","周杰伦","王大师","刘德华"} print(setvar) #...
python字典dict的成对运算
weixin_30399797的博客
12-21 298
dict = {'age': 18, 'name': 'jin', 'sex': 'male', }# for k,v in dict.items():# print(k,v)# v1 = dict['name']# print(v1)# v2 = dict["name1"] #报错# print(v2)# print(dict.get("anme2","没有这个键")) #默认返回n...
python cookbook 1.8 字典dict的运算，求最小值最大值排序
别说话写代码的博客
01-08 396
#1.8字典的运算 在数据字典中进行一些运算 求最大最小或者排序等 d = { #假设数据为股票名称和价格的映射 'ms':50, 'apple':80, 'google':25, 'face':100, 'twt':76 } minprice=min(zip(d.values(),d.keys())) #使用zip()将key和value...
Dict字典
weixin_46072106的博客
12-05 242
""" 字典：有dict1 = {'key':'value', 'key2':'value2'} 操作:查找：dict1['key'] 添加：dict1['key3']='value3' 修改：dict1['key'] = 'value4' 删除：dict.pop('key') 存在：'key1' in dict 遍历：for k in dict1: print(k) for v in dict.values(): print(v) for k, v in dict1.items(): print(k,.
Python-day01课下练习一（存储数据结构）
weixin_48370579的博客
04-18 339
题目使用python实现九九乘法表 通过预习后，使用python一行实现九九乘法表 for i in range(10): if i == 0: continue else: for j in range(i+1): if j == 0: continue else: print(i, "*", j, "= ", j * i) print('\n'.join([' '.join([f"{j}x{...
跟老齐学Python之dict()的操作方法
01-20
dict的很多方法跟list有类似的地方，下面一一道来，并且会跟list做一个对比 嵌套 嵌套在list中也存在，就是元素是list，在dict中，也有类似的样式： >>> a_list = [[1,2,3],[4,5],[6,7]] >>> a_list[1][1] 5 >>> a_...
python 实现dict转json并保存文件
09-18
在Python编程中，数据结构与数据的序列化与反序列化是常见的操作。特别是当我们需要在不同的程序之间传递数据或者将数据持久化存储时，JSON（JavaScript Object Notation）格式因其简洁、易读且被广泛支持的特点，...
Python数据结构dict常用操作代码实例
09-17
字典是无序的，且支持动态添加、删除键值对，是Python中非常重要的数据结构之一。本文将深入探讨Python字典的常用操作，并通过代码实例进行说明。 1. **初始化字典** - `dict()`：创建一个空字典。 - `dict...
python dict如何定义
09-16
在Python编程语言中，字典（dict）是一种非常重要的数据结构，它存储键值对，用于快速查找和访问数据。本文将详细介绍如何定义和操作Python字典。 1. **字典的定义** Python字典由一对大括号 `{}` 包裹，其中包含...
Python数据类型之Dict字典实例详解
09-19
在Python编程语言中，字典（Dict）是一种非常重要的数据结构，它以键值对的形式存储数据，提供了高效的数据检索机制。下面将详细介绍字典的基本概念、创建方法、操作以及与列表（List）的区别。 1. 字典概述 字典是...
Python 字典按值排序
I'm George 的博客
11-27 1367
python 字典（dict）默认使用的是只根据 key 排序，如果需要将字典按值排序的话，那可以用下面的几种方法来进行： 我们主要是使用 sorted 函数操作： def sorted(iterable: Iterable[_T], key: Optional[Callable[[_T], Any]]=..., reverse: bool=...) Return a new list conta...
Python字典（dict）数据类型练习题
O2_H2O的博客
02-22 1357
Python字典（dict）数据类型练习题
python怎么打印字典_python的dict()字典数据类型的方法详解以及案例使用
weixin_39685024的博客
11-23 1215
一、之前的回顾# int 数字# str 字符串# list 列表# tuple 元组# dict 字典字典中最重要的方法keys()values()items()getupdate字典是以"key":"value"的方式存储的1、字典里面是键值对，每个元素之间也是用逗号分隔，是用{}大括号括起来的字典里面的value可以是任何值，可以无限嵌套列表和元组布尔值(不能跟0或1一起出现，当key里面...
python字典倒序_如何使用Python3实现Dict字典的倒序输出
weixin_29758513的博客
02-10 3221
用户提问ATDict = {'amy':{'年龄':22,'体重':43,'学历':'本科'},'jim':{'年龄':33,'体重':54,'学历':'研究生'},'pip':{'年龄':44,'体重':65,'学历':'博士'},'sdy':{'年龄':55,'体重':76,'学历':'大专'}}for (k, v) in ATDict.items():print(k, v)输入如下：amy ...
C#字典Dictionary排序（顺序、倒序）
热门推荐
Peter的博客
05-16 1万+
这里是针对.NET版本过低的排序方式，没怎么用过，记录一下； 一、创建字典Dictionary 对象 　　假如 Dictionary 中保存的是一个网站页面流量，key 是网页名称，值value对应的是网页被访问的次数，由于网页的访问次要不断的统计，所以不能用int作为 key，只能用网页名称，创建 Dictionary 对象及添加数据代码如下： Dictionary<string, int> dic = new Dictionary<string, int&...
dict常见方法
去远方
08-26 4037
1. 定义 字典是一种可变容器模型, 且可存储任意类型对象.具有极快的查找速度. 字典是一种通过名字或者关键字应用的数据结构, 其键可以是数字,字符串,元组,这种结构类型称之为映射.基本的操作如下: (1)len( ) 返回字典中键->值对的数量 (2)d[k] 返回关键字对应的值 (3) d[k] = v 将值关联到键值k上 (4) del d[k] 删除键值为k...
python dict基本用法
potato123232的博客
07-09 4873
目录 1没什么用的函数 1.1比大小的四个函数__ge__(),__gt__(),__le__(),__lt__() 1.2访问属性后自动调用 __getattribute__() 1.3实例化后自动调用 __init__() 1.4实例化后自动调用，如果__new__()存在则不执行__init__() __new__() 1.5生成key的迭代器，让字典中的key可以遍历 __iter__() 1.6生成keys的迭代器 keys() 2不常用...
dict.keys()和dict.items()对象的差并交运算
Jack的博客
09-28 786
问题引入：有两个字典，找出它们之间相同的地方 a = {'x': 1, 'y': 2, 'z': 3} b = {'w': 10, 'x': 11, 'y': 2} a.keys() Out[3]: dict_keys(['y', 'x', 'z']) a.keys() &amp; b.keys() Out[4]: {'x', 'y'} a.keys() ...
Python核心数据类型之字典类型及其运算
Field_Yang的博客
06-04 1959
Python核心数据类型之字典类型及其运算字典：dict字典在其它编程语言中又称作关联数组或散列表；通过键实现元素存取；是无序集合；可变类型容器，长度可变，支持异构和嵌套；格式：{key1:value1, key2:value2, ...}{}: 空字典{'x': 32, 'y': [1,2,3]}字典复制：d2 = d1.copy()d3 = d1字典内置方法：d1.clear()：清除字典中所...
python的dict操作
最新发布
09-09
Python中的字典（dict）是一种无序的键值对数据结构。它可以用于存储和操作具有唯一键的数据。 要创建一个字典，可以使用花括号 {} 或 dict() 函数。以下是一些常见的字典操作示例： 1. 添加或更新键值对： ```...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值