Python刷题系列(4)_字典dict

温欣2030

已于 2022-05-10 18:24:56 修改

阅读量625

点赞数 1

分类专栏： # 【Python刷题】文章标签： python 开发语言

于 2022-05-10 18:23:30 首次发布

本文链接：https://blog.csdn.net/wxfighting/article/details/124659117

版权

【Python刷题】专栏收录该内容

10 篇文章 11 订阅

订阅专栏

注：字典的题目刷的比较少，没有深入去刷一些很难的或者比较复杂的题目，只是对字典有一个大概的了解。

Python 字典

Python字典是无序对象集（如列表）的容器。对象由大括号 { } 包围。字典中的项是以逗号分隔的键：值对列表，其中键和值是 Python 数据类型。

1、按值对字典进行排序（升序和降序）

编写一个Python程序来按值对字典进行排序（升序和降序）。

import operator
d = {1: 2, 3: 4, 4: 3, 2: 1, 0: 0}
print('Original dictionary : ',d)
sorted_d = dict(sorted(d.items(), key=operator.itemgetter(1)))
print('Dictionary in ascending order by value : ',sorted_d)
sorted_d = dict( sorted(d.items(), key=operator.itemgetter(1),reverse=True))
print('Dictionary in descending order by value : ',sorted_d)

'''
Original dictionary :  {1: 2, 3: 4, 4: 3, 2: 1, 0: 0}
Dictionary in ascending order by value :  {0: 0, 2: 1, 1: 2, 4: 3, 3: 4}
Dictionary in descending order by value :  {3: 4, 4: 3, 1: 2, 2: 1, 0: 0}
'''

注：
1、上面代码的operator.itemgetter(1)，表示找到d当中维度为1的元素，也就是字典当中的值，如果改成operator.itemgetter(0)，则是找到字典当中每个元素的键。

2、operator.itemgetter(1) 就是按照字典的值进行排序，operator.itemgetter(0) 就是按照字典的键进行排序

【1】item

字典中的items()函数：以列表返回可遍历的(键, 值) 元组数组。

d = {1: 2, 3: 4, 4: 3, 2: 1, 0: 0}
print(d.items())
print(type(d)) 
print(type(d.items())) 

'''
dict_items([(1, 2), (3, 4), (4, 3), (2, 1), (0, 0)])
<class 'dict'>
<class 'dict_items'>
'''

【2】operator.itemgetter

operator模块提供的itemgetter函数用于获取对象的哪些维的数据
具体内容请点击：operator.itemgetter

2、向字典添加新键值对

d = {0:10, 1:20}
print(d)
d.update({2:30})
print(d)

'''
{0: 10, 1: 20}
{0: 10, 1: 20, 2: 30}
'''

【3】update

语法：dict.update(dict2)
概述：Python 字典的 update() 函数把字典 dict2 的键/值对更新到 dict 里。
参数：dict2 – 添加到指定字典dict里的字典。
返回：无

3、连接以下字典以创建新字典

编写一个Python程序来连接以下字典以创建一个新字典。

dic1={1:10, 2:20}
dic2={3:30, 4:40}
dic3={5:50,6:60}
dic4 = {}
for d in (dic1, dic2, dic3): dic4.update(d)
print(dic4)

'''
{1: 10, 2: 20, 3: 30, 4: 40, 5: 50, 6: 60}
'''

4、合并两个 Python 字典

编写一个 Python 脚本来合并两个 Python 字典。

d1 = {'a': 100, 'b': 200}
d2 = {'x': 300, 'y': 200}
d = d1.copy()
d.update(d2)
print(d)

'''
{'a': 100, 'b': 200, 'x': 300, 'y': 200}
'''

5、使用for循环迭代字典

d = {'Red': 1, 'Green': 2, 'Blue': 3} 
for x,y in d.items():
     print(x, 'corresponds to ',y) 
        
'''
Red corresponds to  1
Green corresponds to  2
Blue corresponds to  3
'''

注：x，y分布代表字典当中的键和值

6、将字典中的所有项目相乘

my_dict = {'data1':-1,'data2':2,'data3':3}
result=1
for key in my_dict:    
    result=result * my_dict[key]

print(result)

'''
-6
'''

注意：与第五题进行区分，这里没有使用items函数

7、从字典中删除键值对

myDict = {'a':1,'b':2,'c':3,'d':4}
print(myDict)
if 'a' in myDict: 
    del myDict['a']
print(myDict)

'''
{'a': 1, 'b': 2, 'c': 3, 'd': 4}
{'b': 2, 'c': 3, 'd': 4}
'''

【4】字典里面的删除方法

Python字典的clear()方法（删除字典内所有元素）

site= {'name': '我的博客地址', 'wenxin': 10000, 'url':'https://blog.csdn.net/'}
pop_obj=site.pop('name') # 删除要删除的键值对，如{'name':'我的博客地址'}这个键值对
print(pop_obj )  # 输出 ：我的博客地址
print(site) # 输出：{'wenxin': 10000, 'url': 'https://blog.csdn.net/'}

Python字典的pop()方法（删除字典给定键 key 所对应的值，返回值为被删除的值）

site= {'name': '我的博客地址', 'a': 10000, 'url':'http://blog.csdn.net/'}
pop_obj=site.pop('name') # 删除要删除的键值对，如{'name':'我的博客地址'}这个键值对
print pop_obj   # 输出 ：我的博客地址

Python字典的popitem()方法（随机返回并删除字典中的一对键和值）

site= {'name': '我的博客地址', 'a': 10000, 'url':'http://blog.csdn.net/'}
pop_obj=site.popitem() # 随机返回并删除一个键值对
print pop_obj   # 输出结果可能是{'url','http://blog.csdn.net/'}

del 全局方法（能删单一的元素也能清空字典，清空只需一项操作）

site= {'name': '我的博客地址', 'a': 10000, 'url':'http://blog.csdn.net/'}
del site['name'] # 删除键是'name'的条目 
del site  # 清空字典所有条目

8、按键对字典进行排序

编写一个Python程序来按键对给定的字典进行排序

color_dict = {'red':'#FF0000',
          'green':'#008000',
          'black':'#000000',
          'white':'#FFFFFF'}
          
print(sorted(color_dict))#输出：['black', 'green', 'red', 'white']

for key in sorted(color_dict):
    print("%s: %s" % (key, color_dict[key]))
'''
black: #000000
green: #008000
red: #FF0000
white: #FFFFFF
'''

分析：直接使用print(sorted(color_dict)) 对字典color_dict进行排序，则是按照键的顺序进行排序，返回值是排序好的键的列表。

9、获取字典中的最大值和最小值

编写一个Python程序来获取字典中的最大值和最小值。

my_dict = {'a':7, 'b':8, 'c': 2}
key_max = max(my_dict.keys(), key=(lambda k: my_dict[k]))
key_min = min(my_dict.keys(), key=(lambda k: my_dict[k]))

print('Maximum Value: ',my_dict[key_max])
print('Minimum Value: ',my_dict[key_min])

'''
Maximum Value:  8
Minimum Value:  2
'''

在这里插入图片描述
注：print(my_dict['a'])得到的就是my_dict这个字典的，键名为a，的对应的值。

【5】keys

keys功能：获取当前字典中所有的键( key )
keys的用法：dict.keys() ->无需传参，返回一个key集合的伪列表

my_dict = { 'name' : 'insane' , 'age' : 33}
my_dict.keys ()
# 输出：dict_keys ( [ 'name' , 'age' ] )  # 不具备列表的所有功能

key_list = list(my_dict.keys())  # 这样后就具备列表的所有功能
key_list
[ 'name' , 'age ' ]

【6】max函数

max(iterable, *[, key, default])
max(arg1, arg2, *args[, key])

函数功能为取传入的多个参数中的最大值，或者传入的可迭代对象元素中的最大值。
默认数值型参数，取值大者；

字符型参数，取字母表排序靠后者。

1、key—可做为一个函数，用来指定取最大值的方法。

2、default—用来指定最大值不存在时返回的默认值。

3、arg1—字符型参数/数值型参数，默认数值型

10、检查字典是否为空

编写一个Python程序来从字典中删除重复项。

my_dict = {}

if not bool(my_dict):
    print("Dictionary is empty")
print(bool(my_dict))

'''
Dictionary is empty
False
'''

11、组合两个字典，为公共键添加值

编写一个Python程序来组合两个字典，为公共键添加值。

from collections import Counter
d1 = {'a': 100, 'b': 200, 'c':300}
d2 = {'a': 300, 'b': 200, 'd':400}
d = Counter(d1) + Counter(d2)
print(d)
'''

Counter({'a': 400, 'b': 400, 'd': 400, 'c': 300})
'''

【7】Counter

主要功能：可以支持方便、快速的计数，将元素数量统计，然后计数并返回一个字典，键为元素，值为元素个数。

from collections import Counter

list1 = ["a", "a", "a", "b", "c", "c", "f", "g", "g", "g", "f"]
dic = Counter(list1)
print(dic)
#结果:次数是从高到低的
#Counter({'a': 3, 'g': 3, 'c': 2, 'f': 2, 'b': 1})

print(dict(dic))
#结果:按字母顺序排序的
#{'a': 3, 'b': 1, 'c': 2, 'f': 2, 'g': 3}

print(dic.items()) #dic.items()获取字典的key和value
#结果:按字母顺序排序的
#dict_items([('a', 3), ('b', 1), ('c', 2), ('f', 2), ('g', 3)])

print(dic.keys())
#结果:
#dict_keys(['a', 'b', 'c', 'f', 'g'])

print(dic.values())
#结果：
#dict_values([3, 1, 2, 2, 3])

print(sorted(dic.items(), key=lambda s: (-s[1])))
#结果:按统计次数降序排序
#[('a', 3), ('g', 3), ('c', 2), ('f', 2), ('b', 1)]

for i, v in dic.items():
    if v == 1:
        print(i)
#结果:
#b

12、在字典中查找对应键的最大 3 个值

from heapq import nlargest
my_dict = {'a':500, 'b':5874, 'c': 560,'d':400, 'e':5874, 'f': 20}  
three_largest = nlargest(3, my_dict, key=my_dict.get)
print(three_largest) 

'''
['b', 'e', 'c']
'''

【8】nlargest

在pandas库里面，我们常常关心的是最大的前几个，比如销售最好的几个产品，几个店，等。之前讲到的head(), 能够看到看到DF里面的前几行，如果需要看到最大或者最小的几行就需要先进行排序。max()和min()可以看到最大或者最小值，但是只能看到一个值。

nlargest()的优点就是能一次看到最大的几行，而且不需要排序。缺点就是只能看到最大的几个，看不到最小的。

【9】get

python字典的get()函数用于返回指定键的值，如果值不在字典中返回默认值。

dict = {'Name': 'Xiaoxiao', 'Age': 38, 'School': 'Hrbeu'}

print (dict.get('School'))
print (dict.get('Sex', "Nothing"))

'''
Hrbeu
Nothing
'''