11. 数据类型 - 字典

痛定思痛。 2024-03-23 19:47 46阅读 0赞

![茶桁的AI秘籍-dictionary][AI_-dictionary]

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'

提示类型错误，`*`实际上也是一样，这里我们就不占用篇幅再多打印一次错误了。说明，字典并不支持这两个基本的数学运算符。想想我们之前提到的`dict`中`key`不能重复其实也就好理解了。如果支持`+`， 那相加的两个字典内`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'])

最后，让我们尝试把`key`和`value`一起获取到：

print(ex1.items())
    
    ---
    dict_items([('b', 2), ('c', 3), ('aa', 'aaaaa')])

### 字典的遍历 ###

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

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

for i in ex1:
        print(i, ':', ex1[i], end="; ")
        
    ---
    b : 2; c : 3; aa : aaaaa;

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

for k, v in ex1.items():
        print(k, ':', v, end="; ")
        
    ---
    b : 2; c : 3; aa : aaaaa;

既然之前介绍的获取上我们可以单独获取`key`和`value`， 当然这里也通通能用：

# 遍历所有的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`不存在，这会插入一个值为`default`的`key`， 并且返回`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中的基础也是重点，大家一定要好好的巩固。

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

[AI_-dictionary]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/016a38d9387246858285539e50aafe29.png