Python基础学习(4) dict详解

简介

  学过c++的小朋友应该知道stl的map，python里的字典跟stl的map类似，却又十分地灵活。而使用字典解题，有时会有许多的帮助。下面是我自己做题时，用到字典的情况，大家可以参考一下。

一、空字典创建

a={}

  这里也是最基本的，不多说什么了。

二、强制转换为字典类型

a=[1,2,3]
b=dict(a)

  之前用字典用的少，后来需要字典的时候，用的是dic，最后发现应该是dict，所以还是应当注意哦~

三、字典推导式

  比如给字典赋初值，可以使用字典推导式。

• 先来看看普通的字典赋初值。

a='python'
b = {}
for char in a:
    b[char]=0

输出：

• 再来看看字典推导式赋初值。

a='python'
b = {char: 0 for char in a}

输出：

  本质上作用效果是一样的。

• 除此之外，还可以通过get赋初值。
  具体的讲解放到get()的方法里，这里不再细说。

四、基本方法

1、keys()

  获取字典的键。
  需要注意的是.keys()返回的是个字典类型，而且不能单独获取某个键（比如我想通过.keys(2)获得第三个键）

a='python'
b={char:0 for char in a}
c=b.keys()#查看字典类型
d=list(b.keys())#转换成列表类型
print(c)
print(d)

输出：

  如果我们想获取某个键，既然传入参数不行，可以通过其他方式巧妙获取。

a='python'
b={char:0 for char in a}
c=b.keys(3)#这个是报错的
d=list(b.keys())[3]#可以将其转换成列表类型再获取

第一个输出：

第二个输出：

2、get()

  .get()也是一个字典方法，用于查找某一个键对应的值。它可以接受两个参数，第一个参数是键，第二个参数是默认值。如果只传入第一个参数，且有对应的键的话，会输出其对应的值，如果没有对应的键，那么会报错。而如果传入两个参数，有对应键，仍会输出其对应的值，第二个参数此时相当于没有用了。相反，如果此时没有对应键，那么就会生成这个键，且赋值为第二个参数。
  看起来可能有些乱，通过下面的例子会好很多。

a='python'
b = {char: i for i, char in enumerate(a)}
#enumerate相当于给a增添了下标，字典b由a依次赋值为0 1 2 3...
c={'p':0,'t':2,'n':5}#字典c我们部分赋了值

d=b.get('p')#这个是传入1个参数，且有对应键
e=c.get('t',0)#这个是传入两个参数，且有对应键
f=c.get('o',4)#这个是传入两个参数，且没有对应键

print(f"d中参数p的值为:{d}")
print(f"e中参数t的值为:{e}")
print(f"f中参数o的值为:{f}")

输出结果：

  参照一下，没有问题的。另一个传入一个参数，没有对应键的我就不弄了，会报错的。
  前面说了，也可以用.get()给字典赋初值，下面来尝试一下。

a='python'
b={}
for char in a:
    b[char]=b.get(char,0)

输出：

3、items()

  字典有获取其键的方法.keys()，那么有没有获取其值的方法呢？如果知道键的话，直接通过下标获取，如果不知道键的话，似乎没有方法获取（之前写完后记得有个地方写错了，可是总是找不到了。今天回顾的时候终于发现了。其实有获取值的方法.values()，下面有详细的解释，这里不说了）。当然items()并不是专门获取值的，而是返回一个dict_items的迭代对象，在遍历字典时经常用到。

a='python'
b = {char: i for i, char in enumerate(a)}
print(b.items())
print(list(b.items()))#与其他可迭代对象一样，可以转换成其他类型

输出：

  可以方便字典使用for循环。

a='python'
b = {char: i for i, char in enumerate(a)}

for key, value in b.items():
    print(f"Key: {key}, Value: {value}")

输出：

4、values()

  之前学的时候怎么记得弄不到值呢？可能是搞混了，不过后来发现.values()的方法后又回来补充了。我觉得跟上面的.keys()方法类似。

a='python'
b={char:0 for char in a}
c=b.values()#查看字典类型
d=list(b.values())#转换成列表类型
print(c)
print(d)

输出结果：

  果然类似，可以类比记忆一下，我这里也就不再展示了。

五、字典实战应用

1、字典排序

（1）按键排序

  这里我们之间使用sorted就可以。因为字典可以直接访问键，所以并不是很困难。sorted返回的是一个列表，如果按键排序的话，返回的就是一个排好序了的列表，并且不影响原来的字典。

terms = {'a': 3, 'b': 1, 'c': 2}
sorted_terms = sorted(terms.keys(),reverse=True)#从大到小排序
print(sorted_terms)  

输出：

  没问题，符合预期

（2）按值排序

  这个是我自己考虑的，如果能按键排序的话，那么应该也就可以按值排序，可是怎么操作呢？需要注意的是，sorted里面还有一个参数，key，代表的是以谁为基准。所以我们可以通过key来达到对字典进行排序的方法。

terms = {'a': 3, 'b': 1, 'c': 2}
sorted_terms = sorted(terms.items(),key=lambda x:x[1],reverse=True)#从大到小排序
print(sorted_terms) 

  解释：terms.items()返回的是一个dict_items类型的可迭代对象，且其内部是按照键、值组成的有序对，详细可见上面的items()方法。后面的key需要传入一个函数，这里的匿名函数中变量x可以理解为前面的terms.items()，而后面的x[1]，则代表有序对中的值(只有x[0]和x[1]这两个，分别代表键和值)。
输出：

  结果上来看，确实按照值进行排序了。所以这个方法也可以按键进行排序。不过与（1）按键排序不同的是，这里返回的是有序对，而另一个只返回了键。所以说，用哪种方法进行排序应结合具体题目来看，选择最合适的方法。

2025.3.21补充
  后续做题得知，可以直接按值排序。

terms = {'a': 3, 'b': 1, 'c': 2}
sorted_terms = sorted(terms.values(),reverse=True)#从大到小排序
print(sorted_terms)  

2、获取最大值

（1）获取值的最大值

• 基本方法

terms={}
s="aaabbbccccddddddafafa"
for i in s:
    terms[i]=terms.get(i,0)+1
a=[terms[i]for i in terms.keys()]
maxlen=max(a)
print(terms)
print(maxlen)

输出结果：

• 直接方法

terms={}
s="aaabbbccccddddddafafa"
for i in s:
    terms[i]=terms.get(i,0)+1
maxlen=max(terms.values())

输出结果：

（2）获取键的最大值

terms={}
s="aaabbbccccddddddafafa"
for i in s:
    terms[i]=terms.get(i,0)+1
maxlen=max(terms.keys())

输出结果：

另
  类比排序，我们也可以使用下面的方法。

terms={}
s="aaabbbccccddddddafafa"
for i in s:
    terms[i]=terms.get(i,0)+1
maxlen=max(terms.items(),key=lambda x:x[1])
print(maxlen)

输出结果：

  结果虽然有些稍有不同，但也确实获得了最大的那项。结合来看，max和sorted，传入的第一个参数，一般是一个可迭代对象，而其返回的是这个可迭代对象元素的类型。因此，我们要按.values排序或者获取最大值，可迭代对象元素类型就是.values()类型。而.keys()同理。对于.items()是一个有序对(keys,values)，所以我们排序或获取最大值后，获得是这个有序对的顺序或者最大值。

3、方法实操

  下面的例子是我将题目简化了的，了解大致情形就行，也不用理解太多，主要看看代码怎么用我上面讲的构建的
  题目大致情境： 多项式乘法，用字典记录系数、指数，并按照指数降幂排序。

  分析： 多项式乘法的话，需要两个for循环（两个多项式，应分别遍历）。每一次相乘，系数、指数都会改变，用列表存储的话，发现很难匹配。后来发现，可以使用字典，键代表指数，值代表系数，整体存储后再按键进行排序，就可以了。

  注意： 不考虑异常及特殊情况，只是单纯地说一下方法

p1=[(3,4),(-5,2),(6,1),(-2,0)]#3x^4-5x^2+6x-2
p2=[(5,20),(-7,4),(3,1)]#5x^20-7x^4+3x

result=[] #存储最后结果的
terms={} #存储相乘之后的指数和系数

for c1,e1 in p1:
    for c2,e2 in p2:
        c=c1*c2 #系数相乘
        e=e1+e2 #指数相加
        if e in terms:
            terms[e]+=c #如果含有这个指数的话，系数相加
        else 
            terms[e]=c #如果没有这个指数，直接赋值
            
#因为是按键排序，有两种方式，我这里都写一写，看看区别

#直接按键排序
a=sorted(terms.items(),key=lambda x:x[0],reverse=True)
result=list(map(lambda x:(x[1],x[0]),a))#因为字典是指数在前，输出应该系数在前，所以需要转化一下
print(result)

#.keys()
for i in sorted(terms.keys(), reverse=True):
            result.append((terms[i], i))
print(result)

输出结果：
  result并不是两个排序在一起输出的的，是我分别生成的，上面放在一起显得清晰一些。