2023-08-08|閱讀時間 ‧ 約 16 分鐘

11. 数据类型 - 字典

raw-image

Hi,大家好。我是茶桁。

关于Python的数据类型,我们已经详细讲解了三种,字符串,列表和元组。那么今天,我们再来讲一种:字典。

字典也是一种数据的集合,由健值对组成的数据集合,字典中的键是不能重复的。

字典中的键必须是不可变的数据类型,常用的键主要是:字符串,整型...

实际上,在之前字符串和列表的铺垫之后,任何数据类型其实都会感觉差不多,当然,每个数据类型也都有自己的特点以及需要注意的地方,不过在方法,操作上也会有很多类同点。

那么,让我们开始学习字典吧。

字典的定义

  • 字典可以通过把以逗号分隔的key:value对列表包含于花括号之内来创建字典。
  • 也可以通过dict构造器来创建

{'jack': 666, 'stored': 777} 或者{666:'jack', 777:'stored'}

让我们开始写代码来做实验:

使用{}定义:

myDict = {'a':1, 'b':2, 'c':2}
print(myDict)

---
{'a': 1, 'b': 2, 'c': 2}

使用dict(key=value, key=value)函数进行定义

myDict = dict(name='张三', sex='male', age=22)
print(myDict)

---
{'name': '张三', 'sex': 'male', 'age': 22}

数据类型的转换:dict(二级容器类型)列表或元组,并且只有二级容器才可以转换

myDict = dict([['a',1], ['b',2], ['c',3]])
print(myDict)

---
{'a': 1, 'b': 2, 'c': 3}

让我们来试试如果不是二级容器类型会如何:

myDict = dict(['a',1], ['b',2], ['c',3])
print(myDict)

---
TypeError: dict expected at most 1 argument, got 3

报错了,提示我们字典最多一个参数,但是现在里面有3个。

再继续试试其他情况:

myDict = dict([[['a',1],['b',2],['c',3]]])
print(myDict)

---
ValueError: dictionary update sequence element #0 has length 3; 2 is required

再次抛出异常,提示字典更新序列元素长度为3,第2位是必填项。

以上可以看出,只有二级容器才能通过dict()函数来做数据类型的转换。

zip压缩函数,dict转类型

ex1 = [1, 2, 3, 4]
ex2 = ['a', 'b', 'c', 'd']

# 压缩过后做的事情其实就是数据类型的转换
myDict = dict(zip(ex1, ex2))
print(myDict)

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

字典的操作

还记得吗,无论是列表还是元组,都支持数学的基本运算符+*。那字典是不是也同样支持?

ex1 = {'a':1, 'b':2, 'c':3}
ex2 = {1:'a', 2:'b', 3:'c', 4:'d'}
print(ex1 + ex2)

---
TypeError: unsupported operand type(s) for +: 'dict' and 'dict'

提示类型错误,*实际上也是一样,这里我们就不占用篇幅再多打印一次错误了。说明,字典并不支持这两个基本的数学运算符。想想我们之前提到的dictkey不能重复其实也就好理解了。如果支持+, 那相加的两个字典内key值如果相同,那到底舍去那一个呢?*法就更容易理解,原本*就是将相同的数据重复乘n份,不支持也就理所应当了。

那么,字典到底支持哪些操作呢?我们接着往下看实验:

首先,让我们尝试获取一下元素,既然字典是key:value形式的,那要想拿到value值,必然是使用key来获取:

res = ex1['a']
print(res)

---
1

拿到元素了,那如果我们是要修改元素呢?直接赋值试试:

ex1['a'] = 111
print(ex1)

---
{'a': 111, 'b': 2, 'c': 3}

看来是有效的,增删改查,我们现在来试试删除:

del ex1['a']
print(ex1)

---
{'b': 2, 'c': 3}

也没毛病。

接下来,当然就是添加元素了:

ex1['aa']  = 'aaaaa'
print(ex1)

---
{'b': 2, 'c': 3, 'aa': 'aaaaa'}

之前我们反复说过字典的一个特点,就是字典不能有重复的key,这也是我们无法使用+*操作字典的原因。那么问题来了,如果我在添加元素的时候key重复了怎么办?

什么怎么办,添加key重复了,那不就变成修改元素了吗?^_^

检测和获取

增删改查我们前三个基本都已经讲完了,那剩下的,就是查了。让我们看看如何检测和获取元素。

成员检测,只能检测key, 无法检测value。是否注意到我们之前一直使用的一句代码for i in range(10), 大家应该都能明白这一句代码是做什么吧?其实,我们坚持是否包含的时候,就可以用in来实现:

print('AA' in ex1)
print('AA' not in ex1)

---
False
True

获取当前字典的长度,只能检测当前有多少个健值对:

print(len(ex1))

---
3

我们还可以获取当前字典中的所有key键:

print(ex1.keys())

---
dict_keys(['b', 'c', 'aa'])

当然,不只是key。实际上,字典中所有的value值,我们一样可以获取到:

print(ex1.values())

---
dict_values([2, 3, 'aaaaa'])

最后,让我们尝试把keyvalue一起获取到:

print(ex1.items())

---
dict_items([('b', 2), ('c', 3), ('aa', 'aaaaa')])

字典的遍历

当我们谈到对字典的遍历时,实际上和检测、获取时一样的。只是写进了遍历循环里而已,让我们来看看吧:

在我们遍历当前字典时,只能获取当前的key, 但是我们可以通过获取到的key来完成获取当前keyvalue:

for i in ex1:
print(i, ':', ex1[i], end="; ")

---
b : 2; c : 3; aa : aaaaa;

这种获取方式就显得略微繁琐一点,既然我们之前有提到一个将keyvalue一起获取到的函数方法,那我们在for里一样可以使用它来将keyvalue一起获取到,只是,我们需要用到两个参数来接收:

for k, v in ex1.items():
print(k, ':', v, end="; ")

---
b : 2; c : 3; aa : aaaaa;

既然之前介绍的获取上我们可以单独获取keyvalue, 当然这里也通通能用:

# 遍历所有的key
for k in ex1.keys():
print(k, end="; ")

print()

# 遍历所有的value
for v in ex1.values():
print(v, end="; ")

---
b; c; aa;
2; 3; aaaaa;

字典的相关函数

和列表、元组一样,字典也有一些相关函数。有些嘛,一看到就很熟悉,在其他地方也能用,可是也有一些事字典专用的。

len(dict): 获取字典的健值对个数

dict.keys() 获取当前字典的所有key键,组成的列表

dict.values() 获取当前字典的所有value值,组成的列表

dict.items()返回由字典项((键,值)对)组成一个新视图

iter(dict)返回以字典的键为元素的迭代器。

res = iter(ex1)
print(next(res))
print(list(res))

---
b
['c', 'aa']

接下来,让我们重新定义一个新的字典来继续下面的函数学习:

myDict = {'a':1, 'b':2, 'c':3, 'd':4, 'e':5}

dict.pop(key) 通过key从当前字典中弹出健值对,删除。

myDict = {'a':1, 'b':2, 'c':3, 'd':4, 'e':5}
myDict.pop('a')
print(myDict)

---
{'b': 2, 'c': 3, 'd': 4, 'e': 5}

这里我们需要注意一个点,就是pop()这个函数其实是有返回值的,会返回当前删除的健值对的value, 我们拿一个变量来接收一下返回值看看:

myDict = {'a':1, 'b':2, 'c':3, 'd':4, 'e':5}
res = myDict.pop('a')
print(res)

---
1

可以看到,res接收到了pop()方法的返回值1

dict.popitem(): 后进先出(LIFO)的方式删除健值对,我们这里需要理解一下什么叫后进先出,就是最后一个加入字典的元素,先出来。

myDict = {'a':1, 'b':2, 'c':3, 'd':4, 'e':5}
myDict.popitem()
print(myDict)

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

pop方法一样,popitem方法也会有一个返回值,不过是返回一个元组。

res = myDict.popitem()
print(res)

---
('e', 5)

上面我们在讲获取的时候提到,可以直接使用key来获取元素的value, 不过如果字典内如果没有这个key的话,程序会报错。除了使用key来直接获取,字典里还有一个get()方法可以用来获取一个元素,用get获取元素存在就返回,不存在也不回报错,而是回返回None

myDict = {'a':1, 'b':2, 'c':3, 'd':4, 'e':5}
print(myDict.keys('f'))

---
TypeError: dict.keys() takes no arguments (1 given)

============
# get方法获取
myDict = {'a':1, 'b':2, 'c':3, 'd':4, 'e':5}
print(myDict.get('f'))

---
None

字典的update方法可以更新对字典进行更新,如果这个key存在的话,就是更新。如果key不存在,则会进行添加。update可是使用key = value的形式更新,也可以直接获取一个新字典进行更新。

myDict = {'a':1, 'b':2, 'c':3, 'd':4, 'e':5}
myDict.update(a=11, b=22)
myDict.update({'c':33, 'f':66})
print(myDict)

---
{'a': 11, 'b': 22, 'c': 33, 'd': 4, 'e': 5, 'f': 66}

 

实际上可以这么理解,update方法在获取其他字典更新原字典就有点像使用数学运算符的+, 区别只是,update是强制把最终确定值定为 + 号后方的值。

字典中还有一个方法setdefault(), 完整的写法为:dict.setdefault(key[, default])这个方法会去字典中找寻存在的key,并且会返回它的值。如果这个key不存在,这会插入一个值为defaultkey, 并且返回default:

myDict = {'a':1, 'b':2, 'c':3, 'd':4, 'e':5}
res = myDict.setdefault('aa', '123')
print(res)
res = myDict.setdefault('a', 2)
print(res)
print(myDict)

---
123
1
{'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'aa': '123'}

需要注意的是,如果这个key在字典中本来就存在,则并不会修改原本key的值,即便你在后面设定了一个default。并且返回的也会是字典内原本的value。也就是说,这个方法只能用来查询和新增。

字典推导式

和之前介绍的数据类型一样,字典也可以使用推导式来实现一些功能。比如:

字典中的健值对位置进行交换,先用普通的方法实现:

myDict = {'a':1, 'b':2, 'c':3}

newDict = {}
for k, v in myDict.items():
newDict[v] = k

print(newDict)

---
{1: 'a', 2: 'b', 3: 'c'}

然后再让我们看看字典推导式如何完成:

myDict = {'a':1, 'b':2, 'c':3}
newDict = {v:k for k, v in myDict.items()}
print(newDict)

---
{1: 'a', 2: 'b', 3: 'c'}

有的小伙伴可能会在推导式前方只写了一个变量来进行接收,那会变成什么样呢?我们来看看:

myDict = {'a':1, 'b':2, 'c':3}
newDict = {v for k, v in myDict.items()}
print(newDict, type(newDict))

---
{1, 2, 3} <class 'set'>

可以看到,最终打印的字典似乎看起来怪怪的,不是key:value的对形式,而是只有一个值。我们type一下能看到,类型并非是字典,而是set, 也就是说这是一个集合。

来让我们再看一个案例,让我们把一个字典中的value值有偶数的对保留下来,并且交换健值对的位置,一样的,让我们先用普通方式做一遍:

myDict = {'a':1, 'b':2, 'c':3, 'd':4, 'e':5, 'f':6}

# 使用普通方式完成
newDict = {}
for k,v in myDict.items():
if v%2 == 0:
newDict[v] = k
print(newDict)

再让我们使用字典推导式来完成

newDict = {v:k for k,v in myDict.items() if v%2 == 0}
print(newDict)

---
{2: 'b', 4: 'd', 6: 'f'}

OK,关于字典的东西基本上也就这么多。在前面学习过字符串和列表之后,是不是其他的容器类数据就没那么难了?很多东西都是普遍适用的,所以我们要活学活用,多思考。

那今天就不留练习题了,咱们下节课是数据类型最后一节了,之后我们开始讲解具体实际应用。字符串和容器类数据是Python中的基础也是重点,大家一定要好好的巩固。

下一节:集合。咱们下节课再见。

分享至
成為作者繼續創作的動力吧!
© 2024 vocus All rights reserved.