@Author: Basil Guo
@Date: Jun. 9, 2021
@Description: Python中内置的数据结构

1. 概述

Python内置了一些数据结构。那什么是数据结构呢？
在此之前我们需要先学习容器概念。容器，顾名思义就是存储一系列东西的容器。比如你有一个果盘，可以放各类水果，那这个果盘就是一个容器。数据结构就是用来实现这个果盘的东西，比如我这个果盘只能放苹果，另一个果盘只能放栗子，有一个果盘只能横着摆放，有的则是一格一格的。这些都是不同的数据结构。数据结构是一门课程，这里只涉及Python内置的四个数据结构。

Python中最常用的四个数据结构是列表list、元组tuple、字典dict、集合set。

2. 列表list

Python中没有数组array的说法。数组，不一定是存放数字，也可以放别的数据类型的数据，如字符串，但是在其它语言中，数组只能存放同一类的数据，或者可以隐式转换的数据（比如int->float，整数也是实数嘛）。

不过Python内置的列表基本上实现了数组的功能。这里我们继续举例。basil很喜欢图书馆，他要去图书馆看书。图书馆的书都放在了书架上。书架现在我们只考虑一个单层的书架，只能放一排书，但是可以无限放。这个书架是封闭的，它有一台配套的机器，只要你给出来书存放的索引，就可以拿到这本书了。这里我们提到了索引，那什么是索引呢？就是一个整数，这个数从0开始，一直增长到这个书架里书本数量numOfBooks-1，为什么要减1呢？因为0也是一个数啊！0~9和1~10都是10个数字，而语言规定要从0开始计起。

在上面的例子中，列表就是这个书架。其中可以存访各种各样的书籍。如果有必要你需要 定义一个书籍类Book来表示书的特征，例如书名、作者、出版时间、出版社、定价、ISBN号等，这里我们简单一点，我们只用书名来表示一本书。

《Python从入门到精通》
《编程小白的第一本Python 入门书》
《Head First Python》
《Python编程：从入门到实践》
《Fluent Python》

OK上面就是我们的书架BookShelf了，现在basil要从书架上拿书了，他向机器输入0，然后拿到了《Python从入门到精通》这本书，输入4拿到了《Fluent Python》这本书，输入5，机器报错，提示输入索引错误，为什么呢？聪明的你想到了吗？

下面说到的类中常用的方法（注意，为了以示区分，我们对类的函数叫做方法，全局的函数才叫函数，方法是需要类对象去调用的，调用使用的符号是.，区分函数和方法，就是有没有使用这个.），方法中第一个参数self都是要写类的时候必须要带的，最后一个参数斜线/则是不用管的，它是CPython所特有的，表示为了效率，这个函数使用的是C语言写的，但是你不用管，你用的时候只需要管中间的参数就行了。至于函数的参数当我们自己写函数的时候我们会讲的，目前只要会使用就行了。

2.1 创建list

如果是在Python中，怎么表示上述过程呢？Python使用[]来表示列表，我们现在去创建书架。

  1. # 这个用于良好的格式打印，我们下面全部要引入它，只引入一次即可
  2. >>> from pprint import pprint
  4. >>> book_shelf = []                        # 我们创建了空书架
  5. >>> book_shelf                            # 里面没有书
  6. []
  8. # 我们又创建了一个书架，这个书架包含了5本书，注意我后面是在逗号断行的哈
  9. >>> book_shelf = ['《Python从入门到精通》', '《编程小白的第一本Python 入门书》',
  10. ... '《Head First Python》', '《Python编程：从入门到实践》', '《Fluent Python》']
  11. >>> pprint(book_shelf)
  12. ['《Python从入门到精通》',
  13.  '《编程小白的第一本Python 入门书》',
  14.  '《Head First Python》',
  15.  '《Python编程：从入门到实践》',
  16.  '《Fluent Python》']

我们有了两个书架，但实际上能用的是只有一个，因为第一个我们只是创建好了之后查看了一下，确认没有书籍，就把它指向了另一个新的书架，那么老的空书架我们就没有办法访问到了，book_shelf指向了新的书架，新书架中有5本书。那还有没有新的创建方法呢？

是的，我们还有创建列表的方法，它就是list()，其实这个list在Python中是一个类，而我们创建出来的列表都叫做对象，类就是一个模板，按照这个模板创建出来的都是对象。例如中国人，其实是一类人，拿着中国公民身份的人都属于中国人这一个类别。说回来，list()其实是list的构造方法，就是按照这个list类来构造list对象，例如给你办理中国的身份证件，你就属于了中国公民（我不清楚，如果有错，还请指出）。它的原型是

  1. list(iterable=(), /)

默认构造一个空的列表，那个=的含义就是，如果你不给我赋值，我就默认使用这个值，而这里值是空()。

2.2 访问元素

我们现在要去访问我们书架中的书了，我们说了只需要给一个索引就可以访问到了。但是请注意，列表是有自己的元素个数的，而这个元素个数限制了索引的范围，这个元素个数可以通过内置函数len(obj, /)计算出来，其中第一个参数obj代表某个对象，后面的/则是CPython的标记，不用管。假设列表元素个数是size = len(bookshelf)，从左向右的索引范围是[0, size)，从右向左索引范围是[-size, -1]，注意区间的闭合性。

  1. >>> len(book_shelf)
  2. 5
  3. >>> book_shelf[0]                                    # 左→右，第1本书
  4. '《Python从入门到精通》'
  5. >>> book_shelf[4]                                     # 左→右，第5本书
  6. '《Fluent Python》'
  7. >>> book_shelf[5]                                     # 不存在，报错
  8. Traceback (most recent call last):
  9.   File "<stdin>", line 1, in <module>
  10. IndexError: list index out of range
  11. >>> book_shelf[-1]                                     # 右→左，第1本书
  12. '《Fluent Python》'
  13. >>> book_shelf[-5]                                     # 右→左，第5本书
  14. '《Python从入门到精通》'
  15. >>> book_shelf[-6]                                     # 不存在，报错
  16. Traceback (most recent call last):
  17.   File "<stdin>", line 1, in <module>
  18. IndexError: list index out of range

Python最重要的一个特性是支持切片slice，所谓的切片就是list的一个部分，它的语法比较新奇，List[start:end]，注意大小写哦，这里列表名叫做List，它的范围是[start, end)，注意闭合性。但如果是从中间到两端，那么会被访问到的那端可以不写明。比如

  1. # 取前3本书
  2. >>> book_shelf[:3]                # 相当于book_shelf[0:3]
  3. ['《Python从入门到精通》', '《编程小白的第一本Python 入门书》', '《Head First Python》']
  4. >>> book_shelf[:-2]             # 相当于是book_shelf[-5:-2]
  5. ['《Python从入门到精通》', '《编程小白的第一本Python 入门书》', '《Head First Python》']
  7. # 取后三本书
  8. >>> book_shelf[len(book_shelf)-3:]
  9. ['《Head First Python》', '《Python编程：从入门到实践》', '《Fluent Python》']
  10. >>> book_shelf[3-len(book_shelf)-1:]   
  11. ['《Head First Python》', '《Python编程：从入门到实践》', '《Fluent Python》']
  13. # 取所有书
  14. >>> pprint(book_shelf[:])        # 两端都不写
  15. ['《Python从入门到精通》',
  16.  '《编程小白的第一本Python 入门书》',
  17.  '《Head First Python》',
  18.  '《Python编程：从入门到实践》',
  19.  '《Fluent Python》']

但是，请注意，所谓的切片切下来的其实是原来的列表的一个复制，如何验证呢？是不是还记着有一个id()函数可以查看内存地址？只有指向同一个地址的引用，才是同一个，也就是它们会相等。

  1. >>> LA = [1, 2, 3, 4, 5]                 # 创建列表内存地址
  2. >>> id(LA)                                # 查看LA内存地址
  3. 2725461086144
  4. >>> LB = LA[:]                          # 切片LB
  5. >>> id(LB)                                # 查看LB内存地址
  6. 2725461103872    
  7. >>> LA == LB                             # 这里为什么会为True呢？
  8. True

一般==都是判断地址，但是为什么上面LA==LB返回为真呢？这是因为Python每个类都有一个内置函数__eq__()，list重写了这个函数，它判断的不是地址，而是列表内容了。那除了判断地址，还能怎么判断它们是两个列表而不是同一个呢？我们学了修改元素再说。

其实这种可以按照索引访问元素的方式有个统一的名称，叫做随机访问。随机访问的意思是，我不需要一个一个的寻访过去，而是可以直接就能访问到我想访问的元素，只要我能够给出索引。对应的是顺序访问，这种方式就需要一个一个的去访问元素，直到找到符合我要求的。为什么会这样子呢？其实这是由于这些数据结构在内存中的组织方式不同的原因。你可以把内存想象成一个无限长的单排书架，书架被分为了很多个等大小的格子，每个格子都有一个编号，一本书可能占不满一个格子，也有可能超出一个格子占多个格子，都没关系。只要你是这样子紧密排列的，我都能直接根据编号访问到书所在的位置，这就是随机访问。但是有的一套书，被拆分成了好几本书，放在了不同位置，比如第一卷放在了位置0x1，第二卷放在了位置0x100（想清楚，这到底是多少，这是16进制哦），第三卷放在了位置0x80（就是这么任性，我要放回来），第四卷放在了位置0x508…而每一卷末尾都指向了下一卷开始存放的位置，我们只有第一卷存放的位置，所以我们要找到第四卷，只能依据这个顺序依次寻找。

我们在列表中存储了哪些元素需要遍历得知，但是具体一个元素在哪里，我们可以使用index(self, value, start=0, stop=9223372036854775807, /)，用于在列表中查找是否有值为value的，如果找到了，那么就返回索引位置，否则，报错提示<value> is not in list。start和stop指定查找位置，这两个是默认参数，是可以省略的。

  1. >>> LA = [1, 2, 3, 4, 5, 6]
  2. >>> LA.index(1)                                    # 要记得索引从0开始啊
  3. 0
  4. >>> LA.index(0)
  5. Traceback (most recent call last):
  6.   File "<stdin>", line 1, in <module>
  7. ValueError: 0 is not in list
  9. # 缺省stop
  10. >>> LA.index(4, 1)
  11. 3
  12. # 参数全写上
  13. >>> LA.index(4, 1, 4)
  14. 3

2.3 添加元素

向列表添加元素使用append(self, object, /)方法，然后就可以添加了，它添加到列表的末尾。

  1. >>> book_shelf.append('《人间失格》')
  2. >>> pprint(book_shelf)
  3. ['《Python从入门到精通》',
  4.  '《编程小白的第一本Python 入门书》',
  5.  '《Head First Python》',
  6.  '《Python编程：从入门到实践》',
  7.  '《Fluent Python》',
  8.  '《人间失格》']

insert(self, index, object, /)可以指定插入的位置。

  1. >>> book_shelf.insert(1, '《利用Python进行数据分析》')
  2. >>> pprint(book_shelf)
  3. ['《Python从入门到精通》',
  4.  '《利用Python进行数据分析》',
  5.  '《编程小白的第一本Python 入门书》',
  6.  '《Head First Python》',
  7.  '《Python编程：从入门到实践》',
  8.  '《Fluent Python》',
  9.  '《人间失格》']

2.4 修改元素

修改元素其实就是重新赋值即可了，例如我们发现最后一本书放错了，我们要换成是《Python数据结构》。

  1. >>> book_shelf[-1] = '《Python数据结构》'        # 不会这么快就忘了-1吧~
  2. >>> pprint(book_shelf)
  3. ['《Python从入门到精通》',
  4.  '《利用Python进行数据分析》',
  5.  '《编程小白的第一本Python 入门书》',
  6.  '《Head First Python》',
  7.  '《Python编程：从入门到实践》',
  8.  '《Fluent Python》',
  9.  '《Python数据结构》']

现在我们也来证明一下上面说的LA和LB是不同的列表，只需要改变其中一个列表的一个值就行。

  1. >>> LA                                         # 原始列表LA
  2. [1, 2, 3, 4, 5]                                    
  3. >>> LB                                        # 来自于LB = LA[:]
  4. [1, 2, 3, 4, 5]
  5. >>> LA[0] = 6                                # 改变LA第一个元素
  6. >>> LA                                        # LA变了第一个元素
  7. [6, 2, 3, 4, 5]
  8. >>> LB                                        # LB第一个元素没变，所以它们不是同一个列表
  9. [1, 2, 3, 4, 5]
  10. >>> LA == LB                                # 这时内存地址和内容都不相等了
  11. False

2.5 删除元素

现在通过学习，我们看完了第一本书要删除它。有什么方法呢？

  1. 使用**del**关键字。它也可以用在这里，它是操作的原列表，也就是原地操作，所以很推荐这种方式，开销很小。当然了，如果作用与列表，这个关键字可以删除整个列表。 ```python

    删除元素

    id(book_shelf)
    2725461103680 del book_shelf[0] pprint(book_shelf) [‘《利用Python进行数据分析》’, ‘《编程小白的第一本Python 入门书》’, ‘《Head First Python》’, ‘《Python编程：从入门到实践》’, ‘《Fluent Python》’, ‘《Python数据结构》’] id(book_shelf)
    2725461103680

删除列表

LA = [1, 2, 3] LA [1, 2, 3] del LA LA Traceback (most recent call last): File ““, line 1, in NameError: name ‘LA’ is not defined ```

  1. 创建一个新列表，这种方式就是我们上面的切片了，它一定是新开的一片内存，所以它的开销会比较大，在列表很大的情况下，这种对比就会特别明显，所以不推荐。这里我们删除《利用Python进行数据分析》，因为我们还没学到这么高深的境界。

    1. >>> book_shelf = book_shelf[1:]
    2. >>> pprint(book_shelf)
    3. ['《编程小白的第一本Python 入门书》',
    4. '《Head First Python》',
    5. '《Python编程：从入门到实践》',
    6. '《Fluent Python》',
    7. '《Python数据结构》']

  2. 现在我们觉着入门书太多了，我们不想再看《Head First Python》，使用**remove(self, value, /)**方法，它会移除我们指定的元素。 ```python

    book_shelf.remove(‘《Head First Python》’) from pprint import pprint pprint(book_shelf) [‘《编程小白的第一本Python 入门书》’, ‘《Python编程：从入门到实践》’, ‘《Fluent Python》’, ‘《Python数据结构》’]

如果移除本来就不在列表中的元素呢？报错

book_shelf.remove(‘《设计模式之禅》’) Traceback (most recent call last): File ““, line 1, in ValueError: list.remove(x): x not in list ```

  1. 使用pop(self, index=-1, /)移除最后一个元素，当然这只是默认，你可以指定index，然后就可以根据索引删除书了。 ```python

    book_shelf.pop() # 这里打印了，因为它会返回index所处的值 ‘《Python数据结构》’ pprint(book_shelf) [‘《编程小白的第一本Python 入门书》’, ‘《Python编程：从入门到实践》’, ‘《Fluent Python》’]

删除index=0处的书

book_shelf.pop(0) ‘《编程小白的第一本Python 入门书》’ pprint(book_shelf) [‘《Python编程：从入门到实践》’, ‘《Fluent Python》’]

删除index=-1处的书

book_shelf.pop(-1) ‘《Fluent Python》’ pprint(book_shelf) [‘《Python编程：从入门到实践》’]

删除index=3处的书

book_shelf.pop(3) Traceback (most recent call last): File ““, line 1, in IndexError: pop index out of range # index超出范围了哦

  1. 好啦，经过筛选，这本《Python编程：从入门到实践》是最适合作为Python入门书籍的。祝你看的愉快。
  2. <a name="xdIYv"></a>
  3. ## 2.6 MISC
  4. 其实list作为一个类，有很多方法，`__`开头结尾的函数都称之为**魔法函数**（没办法，我叫方法只是为了区分，但是人家Python就是这样叫的，改了不好），一般不会直接使用。而字母开头的方法，则使用较多。使用时，如果不会用，可以使用`help(list)`查看所有的方法，查看具体方法，比如`append()`，那么就使用`help(list.append)`。
  5. <a name="O7mYT"></a>
  6. ### 2.6.1 清空列表内容
  7. 使用`clear(self, /)`，它可以在不销毁当前列表，然后清空其中内容。怎么验证呢？只要内存地址没变，不就代表没有销毁嘛！
  8. ```python
  9. LA = [1, 2, 3]
  10. id(LA)
  11. 1698738654592
  12. LA.clear()
  13. id(LA)                        # 没骗你吧，地址没有改变
  14. 1698738654592
  15. LA
  16. []

2.6.2 列表复制

copy(self, /) 浅复制，就是只复制引用，不复制具体数据，而深复制则是复制数据。其实List[:]也能复制一份，也是浅复制。 ```python

浅复制，其实就是LA = LL[:]

LL = [[1, 2]] LA = LL.copy() LA [[1, 2]] LL[0][0] = 3 LL [[3, 2]] LA # LA竟然跟着一起变了！！！ [[3, 2]]

深复制：需要LA不随LL的改变而改变

LL = [[1, 2]] LA = [] for l in LL: # 深复制需要遍历每一层数组 … if type(l) is list: … LA.append(l[:]) … else: … LA.append(l) … LA [[1, 2]] LL[0][0] = 3 LL # LL变了 [[3, 2]] LA # LA没变 [[1, 2]]

  1. <a name="M1XQs"></a>
  2. ### 2.6.3 统计某个值出现次数
  3. `count(self, value, /)`统计`value`在列表中出现的次数，如果没有出现，就是0咯。
  4. ```python
  5. LA = [1, 1, 2, 3]
  6. LA.count(1)
  7. 2
  8. LA.count(2)
  9. 1
  10. LA.count(5)
  11. 0

2.6.4 扩展列表

extend(slef, iterable, /)，这个是用于扩展列表的，之前我们所说的都对一个列表进行操作，但是当两个列表合并的时候该怎么做呢？就使用这个函数即可。当然使用+也是可以的，不过这种方式有效率问题，它是创建了一个新的列表，看地址。 ```python

使用+

LA = [1, 2, 3] LB = [4, 5, 6] id(LA) 1698738654592 id(LB) 1698738655040 LC = LA + LB LC # 这就是新建的列表 [1, 2, 3, 4, 5, 6] LA # 没有改变LA的值 [1, 2, 3] LB # 也没有改变LB的值 [4, 5, 6] id(LC) # 可以看到LC的地址和LA和LB都不相同 1698738654016

extend

LA.extend(LB) # 现在扩展LA LA # LA得到了扩展 [1, 2, 3, 4, 5, 6] id(LA) # 但是它的内存地址没有改变 1698738654592 id(LB) # LB还是没有改变 1698738655040 LB [4, 5, 6]

<a name="v9BbF"></a>
### 2.6.5 反转列表
`reverse(self, /)`这个可以把列表元素前后对换，就是首元素和尾元素依次对调。
```python
hello = ['h', 'e', 'l', 'l', 'o']
id(hello)
1698741229760
hello.reverse()
hello
['o', 'l', 'l', 'e', 'h']
id(hello)
1698741229760                # 地址没变，所以是在原地反转的哦

2.6.6 列表排序

有时候，我们需要对列表排序，比如你去购买商品的时候，有各种排序方式：距离、价格、评价、综合等，而且还分从低到高（ASC），还有从高到低（DESC）。这时候就是用到sort(self, /, *, key=None, reverse=False)，很不好介绍，不过前两个参数self和/不用管，和上面一样，*你就当作是待排序列表吧，key是排序的依据，默认None则是按照字典序，其实是ASCII码的顺序，不过以后肯定不是这样子用的，先不用管那么多。reverse=False也就是默认是正序，不是反序，就是上面reverse()。但是要明确一点，不同数据类型的元素没有办法比较，也就没法子排序，所以要排序就要存储相同类型的元素。 ```python LA = [0, 1, 2, ‘a’, ‘b’, ‘c’, ‘+’, ‘A’, ‘-‘, ‘B’] LA.sort() # 不能排序哦 Traceback (most recent call last): File ““, line 1, in TypeError: ‘<’ not supported between instances of ‘str’ and ‘int’ LA.pop(0) # 删除位置0的元素 0 LA.pop(0) 1 LA.pop(0) 2 LA.sort() # 好啦，可以排序啦，都是字符串了 LA [‘+’, ‘-‘, ‘A’, ‘B’, ‘a’, ‘b’, ‘c’]

另一个列表排序

L = [‘ABC’, ‘abc’, ‘AB’, ‘Ab’, ‘aB’] L.sort() L [‘AB’, ‘ABC’, ‘Ab’, ‘aB’, ‘abc’]

<a name="Ji2dZ"></a>
## 2.7 混合存储
其实列表可以**同时**存储不同数据类型的元素，但是坚决不推荐。不过偶尔也能使用一下。列表可以嵌套列表，即列表的元素可以是列表，也可以是任意的数据类型，之后介绍的元组、集合、字典都可以的，自定义的类也是可以的。
```python
l = ['a', 1, ['a', 'b', 'c']] 
l[0]                                # 第一个
'a'
l[1]                                # 第二个
1
l[2]                                # 第三个，是列表
['a', 'b', 'c']
l[2][0]                                # 列表继续这样子访问，修改什么的
'a'
l[2][2] = 'cccc'                    # 修改元素啦
l
['a', 1, ['a', 'b', 'cccc']]

3. 元组tuple

元组其实很类似于列表，但是呢，它的值一旦确定了就不能改变了，这个不能改变不只是元素的值不能改变，而且包含元素的个数也不能改变。所以既不能修改，也不能删除元素。

3.1 创建元组

使用()来创建元组，但是呢，如果只有一个元素，需要(element,)类似这样子，就是加了一个,，这样才是元组，否则不是。

T = (1)
T
1
type(T)
<class 'int'>

T = (1,)                            # 这才是元组
type(T)
<class 'tuple'>    
# 新的元组，你不是说不能改变元组吗？
# 这里我们并没有改变元组，只是把指向它的引用给指向了另一个地方。

T = (1, 2, 3)

或者使用tuple(iterable=(), /)，这里同列表很像，你可以传值，否则就创建空元组。空元组貌似没什么用，但是以后学了函数和类之后才能看出来。这个函数称为元组构造器，可以构造元组，也可以把list、set等转换为元组。

T = tuple()
T
()
L = ['a', 'b', 'c']
T = tuple(L)
T
('a', 'b', 'c')

3.2 访问元素

访问元素和列表一样，使用索引。 ```python T (‘a’, ‘b’, ‘c’) T[0] ‘a’ T[-1] ‘c’

不能修改

T[0] = ‘d’ Traceback (most recent call last): File ““, line 1, in TypeError: ‘tuple’ object does not support item assignment

不能删除

del T[0] Traceback (most recent call last): File ““, line 1, in TypeError: ‘tuple’ object doesn’t support item deletion ```

3.3 MISC

元组只有两个方法。还都和列表一样，不详讲了。

  1. count(self, value, /)
  2. index(self, value, start=0, stop=9223372036854775807, /)

    4. 字典dict

    字典是什么？字典是新华字典吗？差不多。其实字典是根据某个值去寻找另一个值，就是根据键找值，字典中的都是键值对。什么是键值对？键其实就是你之前在学习列表、元组时候的索引，根据这个键可以快速找到值，它底层使用的是Hash函数，可先不管它是啥，反正就是找值很快。

有了列表那种按照索引的，为什么还需要这种按照键的呢？一是这种方式更快，二就是它的键可以不是数值，可以是任何不可变的数据类型的值，None空值类型也可以作为键。但是列表list()、迭代器range()不能作为字典的键，而数值类型、字符串、元组tuple()可以作为键。对字典的值的要求很松，任何类型都行，可变也行。

4.1 创建字典

字典使用{}来表示，也可以使用dict()来创建空字典，使用dict(mapping)来创建，这种其实是从一个字典创建新的字典，是做了浅复制。在学了访问方式之后，我们再验证是不是浅复制。

>>> d = {None: None}                    # 创建一个只含有一个键值对的字典，键和值都是None
>>> dd = dict(d)                        # 根据d创建字典dd，就是浅复制
>>> id(d)
1698741644928
>>> id(dd)
1698741697216

4.2 添加元素

现在有了一个空的字典，或者单纯的就是想要往其中添加新的键值对，该怎么做呢？


>>> d[None] = 1                            # 
>>> d
{None: 1}
>>> dd
{None: None}
>>> d[None] = list()
>>> d
{None: []}
>>> dd = dict(d)
>>> dd
{None: []}
>>> dd[None] = 1
>>> dd
{None: 1}
>>> d
{None: []}
>>> dd = dict(d)
>>> dd[None].append(1)
>>> dd
{None: [1]}
>>> d
{None: [1]}

4.3 访问元素

>>> d = {None: None}
>>> dd = dict(d)
>>> id(d)
1698741644928
>>> id(d)
1698741644928
>>> d[None] = 1                            # 这是访问字典的方式
>>> d
{None: 1}
>>> dd
{None: None}
>>> id(dd)
1698741697216
>>> d[None] = list()
>>> d
{None: []}
>>> dd = dict(d)
>>> dd
{None: []}
>>> dd[None] = 1
>>> dd
{None: 1}
>>> d
{None: []}
>>> dd = dict(d)
>>> dd[None].append(1)
>>> dd
{None: [1]}
>>> d
{None: [1]}

4.4 修改元素

4.4 删除元素

我们用一下吧，现在我要打印支票，但是呢，我给你的是阿拉伯数字，需要你将它转为大写数字汉字。该怎么做呢？假设我们不管单位，就是拾、佰、仟、萬、圆这些东西。

money = input('Enter your cost: ')

dict = {0: '零', 1:'壹', 2:'贰', 3:'叁', 4:'肆', 5:'伍', 6:'陆', 7:'柒', 8:'捌', 9:'玖'}

for i in money:                        # string也是可迭代的iterable
    print(dict[int(i)], end='')        # i是字符串类型哦，所以要转为int

print()

5. 集合set

想想数学上的集合有什么特性呢？无序性、确定性、唯一性。那么好了，这里的set也是这样的。

5.1 创建集合

集合创建使用的是set()创建空集合，或者使用set(iterable)把可迭代的对象转为集合，例如list，tuple，range。请记住{}是创建字典类型的哦，不是集合类型的。

>>> s = set()
>>> type(s)
<class 'set'>
>>> s
set()
>>> L = [1, 1, 2, 3]
>>> s = set(L)
>>> s                        # 它去重了
{1, 2, 3}

5.2 访问元素

5.3 删除元素