Python中常见的数据结构可以统称为容器。序列（如列表和元组）、映射（如字典）以及集合（set）是三类主要的容器。大多数编程语言都有特定的数据结构来存储由一系列元素组成的序列，这些元素以它们所处的位置为索引：从第一个到最后一个依次编号。

列表和元组

列表和元组可以简单理解为由任意类型元素组成的序列。与字符串不同的是，元组和列表并不需要所含元素的种类相同，每个元素都可以是任何python类型的对象。值得一提的是，元组是不可变的，给元组赋值的时候，这些值便固定在了元组里，无法修改。然而，列表中的元素却是可变的，这意味可以随时修改其中的元素。

列表

列表可以用顺序和位置定位某一元素，尤其是当元素的顺序或内容经常发生改变时。列表是可变的。可以直接对原始列表进行修改：添加，删除或覆盖已有元素。在列表中，允许出现相同值的元素。

使用[ ]或list()创建列表

列表可以由零个或多个元素组成，元素之间用逗号分开，整个列表被方括号所包括：

>>> animals_list = ['dog', 'cat', 'panda', 'bird', 'rabbit']
>>> human_list = [ ]
>>> fruits_list = ['apple', 'pear', 'pineapple', 'banana', 'apple']  #列表的元素允许重复

使用list()将其他数据类型转换成列表

Python 的 list() 函数可以将其他数据类型转换成列表类型。

>>> list('abc')
['a', 'b', 'c']
>>> list()  #生成一个空列表
[]
>>> a_tuple = ('ha', 'ha', 'ha')   #将一个元组转换为列表
>>> list(a_tuple)
['ha', 'ha', 'ha']

使用[offset]获取元素

和字符串一样，通过偏移量可以从列表中提取对应位置的元素：

>>> words_list = ['a', 'b', 'c']
>>> words_list[0]
'a'
>>> words_list[1]
'b'
>>> words_list[2]
'c'

同样，负偏移量代表从尾部开始计数：

>>> words_list[-1]
'c'
>>> words_list[-2]
'b'
>>> words_list[-3]
'a'

当指定的偏移量小于起始位置或者大于末尾位置时，会产生异常（错误）：

>>> words_list[5]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range
>>> words_list[-5]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range

列表嵌套列表

列表可以包含各种类型的元素，包括其他列表，如下所示：

>>> fruit_list = ['apple', 'banana', 'pear']
>>> drink_list = ['coffee', 'milk', 'juice']
>>> food_list = [fruit_list, drink_list]

这个列表结构的样子：

>>> food_list
[['apple', 'banana', 'pear'], ['coffee', 'milk', 'juice']]

访问列表中的元素：

>>> food_list[0]     #  [0]指向列表fruit_list  
['apple', 'banana', 'pear']
>>> food_list[1]
['coffee', 'milk', 'juice']
>>> food_list[0][0]   #  [0][0]指向列表fruit_list的第一个元素
'apple'
>>> food_list[0][1]
'banana'
>>> food_list[0][2]
'pear'
>>> food_list[1][0]
'coffee'
>>> food_list[1][1]
'milk'
>>> food_list[1][2]
'juice'

使用[offset]修改元素

可以通过偏移量访问元素，也可以通过赋值对它进行修改：

>>> animals_list = ['dog', 'cat', 'panda', 'bird', 'rabbit']
>>> animals_list
['dog', 'cat', 'panda', 'bird', 'rabbit']
>>> animals_list[0] = 'duck'
>>> animals_list
['duck', 'cat', 'panda', 'bird', 'rabbit']

列表的偏移量必须是合法有效的。但这种方式无法修改字符串中的指定字符。因为字符串是不可变的，列表是可变的。

使用切片提取元素

列表中的切片依然是一个列表，可以像用字符串切片的方法一样来对列表进行切片：

>>> animals_list[0:2]
['dog', 'cat']
>>> animals_list[::2]
['dog', 'panda', 'rabbit']
>>> animals_list[1::2]
['cat', 'bird']

将列表倒序：

>>> animals_list[::-1]
['rabbit', 'bird', 'panda', 'cat', 'dog']

使用append()添加元素至尾部

传统的向列表中添加元素的方法是利用 append() 函数将元素一个个添加到尾部：

>>> animals_list.append('tiger')
>>> animals_list
['dog', 'cat', 'panda', 'bird', 'rabbit', 'tiger']
>>> others = ['fish', 'lion']
>>> animals_list.append(others)
>>> animals_list    # others被当作单独的一个元素，而不是把其中的元素添加进去。
['dog', 'cat', 'panda', 'bird', 'rabbit', 'tiger', ['fish', 'lion']]

使用extend()或+=合并列表

使用 extend() 可以将一个列表合并到另一个列表中：

>>> plants_list = ['rose', 'sunflower', 'tulip']
>>> others = ['tomato', 'potato']
>>> plants_list.extend(others)
>>> plants_list
['rose', 'sunflower', 'tulip', 'tomato', 'potato']
#   +=合并列表
>>> plants_list = ['rose', 'sunflower', 'tulip']
>>> others = ['tomato', 'potato']
>>> plants_list += others
>>> plants_list
['rose', 'sunflower', 'tulip', 'tomato', 'potato']

使用insert()在指定位置插入元素

使用 insert() 可以将元素插入到列表的任意位置。指定偏移量为 0 可以插入列表头部。如果指定的偏移量超过了尾部，则会插入到列表尾部：

>>> plants_list
['rose', 'sunflower', 'tulip', 'tomato', 'potato']
>>> plants_list.insert(3, 'pepper')
>>> plants_list
['rose', 'sunflower', 'tulip', 'pepper', 'tomato', 'potato']
>>> plants_list.insert(9, 'mango')
>>> plants_list
['rose', 'sunflower', 'tulip', 'pepper', 'tomato', 'potato', 'mango']

使用del删除指定位置的元素

刚才 insert() 添加了辣椒和芒果，但现在要删除辣椒，芒果，可以用del()函数来指定位置删除元素：

>>> plants_list
['rose', 'sunflower', 'tulip', 'pepper', 'tomato', 'potato', 'mango']
>>> del plants_list[-1]
>>> plants_list
['rose', 'sunflower', 'tulip', 'pepper', 'tomato', 'potato']
>>> del plants_list[3]
>>> plants_list
['rose', 'sunflower', 'tulip', 'tomato', 'potato']

使用remove()删除具有指定值的元素

现在要删除番茄，remove() 函数可以指定要删除的值：

>>> plants_list
['rose', 'sunflower', 'tulip', 'tomato', 'potato']
>>> plants_list.remove('tomato')
>>> plants_list
['rose', 'sunflower', 'tulip', 'potato']

使用pop()获取并删除指定位置的元素

pop() 可以获取列表中指定位置的元素，但在获取完成后，该元素会被自动删除。如果 pop() 指定了偏移量，它会返回偏移量对应位置的元素；如果不指定，则默认使用 -1。因此，pop(0) 将返回列表的头元素，而 pop() 或 pop(-1) 则会返回列表的尾元素：

>>> plants_list
['rose', 'sunflower', 'tulip', 'potato']
>>> plants_list.pop()
'potato'
>>> plants_list
['rose', 'sunflower', 'tulip']
>>> plants_list.pop(1)
'sunflower'
>>> plants_list
['rose', 'tulip']

使用index()查询具有特定值的元素位置

如果想知道等于某一个值的元素位于列表的什么位置，可以使用 index() 函数进行查询：

>>> plants_list
['rose', 'tulip']
>>> plants_list.index('tulip')
1
>>>

判断值是否存在

可以使用in来判断值是否存在，存在为True，不存在为False

>>> plants_list
['rose', 'tulip']
>>> 'rose' in plants_list
True
>>> 'tomato' in plants_list
False

使用count()记录指定的值出现次数

>>> num_list = ['1', '2', '3', '4', '5', '1']
>>> num_list.count('1')
2

使用join()转换为字符串

>>> num_list
['1', '2', '3', '4', '5', '1']
>>> ', '.join(num_list)
'1, 2, 3, 4, 5, 1'

使用sort()列表排序

sort() 会对原列表进行排序，改变原列表内容；sorted() 则会返回排好序的列表副本，原列表内容不变。如果列表中的元素都是数字，它们会默认地被排列成从小到大的升序。如果元素都是字符串，则会按照字母表顺序排列：

>>> word_list = ['a', 'b', 'w', 'e', 'z', 'c']
>>> word_list_sortet = sorted(word_list)
>>> word_list_sortet
['a', 'b', 'c', 'e', 'w', 'z']
>>> word_list   # sorted()创建一个副本，不会改变原有列表
['a', 'b', 'w', 'e', 'z', 'c']
>>> num_list = [1, 2, 9, 4, 5, 1]
>>> num_list.sort()
>>> num_list    # sort()会修改原有列表
[1, 1, 2, 4, 5, 9]
>>> num_list.sort(reverse=True)   #默认的排序是升序的，通过添加参数 reverse=True 可以改变为降序排列：
>>> num_list     
[9, 5, 4, 2, 1, 1]

列表中的所有元素最好都是同一种类型时，虽然有些时候甚至多种类型也可——例如整型和浮点型——只要它们之间能够自动地互相转换：

>>> numbers = [2, 1.9, 4.0, 3, 0]
>>> numbers.sort()
>>> numbers
[0, 1.9, 2, 3, 4.0]

使用len()获取长度

>>> numbers
[0, 1.9, 2, 3, 4.0]
>>> len(numbers)
5

copy()复制列表

如果将一个列表赋值给了多个变量，改变其中的任何一处会造成其他变量对应的值也被修改，如下所示：

>>> a = [1,2,3]
>>> b = a
>>> a[0] = 0
>>> a
[0, 2, 3]
>>> b
[0, 2, 3]

b 与 a 实际上指向的是同一个对象，因此，无论我们是通过 a 还是通过 b 来修改列表的内容，其结果都会作用于双方。因此要想复制一个列表可以通过copy()函数，list() 转换函数，列表切片 [:] 这三种任意一种方法来实现：

>>> a = [1, 2, 3]
>>> b = a.copy()
>>> c = list(a)
>>> d = a[:]
>>> a[0] = 0
>>> a
[0, 2, 3]
>>> b
[1, 2, 3]
>>> c
[1, 2, 3]
>>> d
[1, 2, 3]

元组

元组由任意类型元素组成的序列。与列表不同的是，元组是不可变的，这意味着一旦元组被定义，将无法再进行增加、删除或修改元素等操作。

使用()创建元组

可以用 () 创建一个空元组：

>>> tuple_test = ()
>>> tuple_test
()

创建包含一个或多个元素的元组时，每一个元素后面都需要跟着一个逗号，即使只包含一个元素也不能省略：

>>> tuple_test = ('a',)
>>> tuple_test
('a',)
>>> tuple_test = ('a', 'b', 'c')     #  如果创建的元组所包含的元素数量超过 1，最后一个元素后面的逗号可以省略：
>>> tuple_test
('a', 'b', 'c')

元组的创建也可以不用（）创建，当然（）的存在可以增加程序的易读性。

>>> tuple_test = 'a', 'b', 'c'
>>> tuple_test
('a', 'b', 'c')

元组可以同时赋值给多个变量，也可以用元组在一条语句中对多个变量的值进行交换，而不需要借助临时变量：

>>> tuple_test = ('word', 'excel', 'ppt')
>>> a,b,c = tuple_test
>>> a
'word'
>>> b
'excel'
>>> c
'ppt'
#利用元组交换变量的值
>>> username = 'xiaoming'
>>> password = '123456'
>>> username, password = password, username
>>> username
'123456'
>>> password
'xiaoming'

tuple() 函数可以用其他类型的数据来创建元组：

>>> test_list = [1, 2, 3, 4, 5]
>>> tuple(test_list)
(1, 2, 3, 4, 5)

字典和集合

字典

字典由键值对（key:value）组成，每个值拥有与之对应的互不相同的（key）。字典中的值的顺序无关紧要，因为字典通过键来访问值。键通常是字符串，但它还可以是 Python 中其他任意的不可变类型：布尔型、整型、浮点型、元组、字符串，以及其他一些类型。字典是可变的，因此可以增加、删除或修改其中的键值对。

使用{}创建字典

用 {} 将一系列以逗号隔开的键值对（key:value）包裹起来即可进行字典的创
建。最简单的字典是空字典，它不包含任何键值对：

>>> dict_test = {}
>>> dict_test
{}

用无限宝石来创造一个字典：

>>> Infinity_Stones = {   #在括号之间输入键值对来创建字典时不强制缩进，这么做是为了增加代码的可读性。
... "green":"Time Stone",
... "blue":"Space Stone",
... "red":"Reality Stone",
... "purple":"Power Stone",
... "yellow":"Mind Stone",
... "orange":"Soul Stone",
... }     #  Python允许在列表、元组或字典的最后一个元素后面添加逗号。
>>> Infinity_Stones
{'green': 'Time Stone', 'blue': 'Space Stone', 'red': 'Reality Stone', 'purple': 'Power Stone', 'yellow': 'Mind Stone', 'orange': 'Soul Stone'}

使用dict()转换为字典

>>> dict_list = [['a', 'b'], ['c', 'd']]
>>> dict(dict_list)
{'a': 'b', 'c': 'd'}
>>> dict_list = [('a', 'b'), ('c', 'd')]
>>> dict(dict_list)
{'a': 'b', 'c': 'd'}
>>> dict_list = ['ab', 'cd']
>>> dict(dict_list)
{'a': 'b', 'c': 'd'}
>>> dict_list = ('ab', 'cd')
>>> dict(dict_list)
{'a': 'b', 'c': 'd'}

使用[key]添加或修改元素

向字典中添加元素需指定该元素的键并赋予相应的值。如果该元素的键已经存在于字典中，那么该键对应的旧值会被新值取代。如果该元素的键并未在字典中出现，则会被加入字典。

#在复仇者联盟电影纽约之战中地球一共由三个无限宝石分别是空间，时间，心灵
>>> Infinity_Stones = {
... "green":"Time Stone",
... "blue":"Space Stone",
... "yellow":"Mind Stone",
... }
>>> Infinity_Stones
{'green': 'Time Stone', 'blue': 'Space Stone', 'yellow': 'Mind Stone'}
#这里空间宝石应该还是宇宙魔方，所以应该将空间宝石修改为宇宙魔方
>>> Infinity_Stones['blue'] = 'Tesseract'
>>> Infinity_Stones
{'green': 'Time Stone', 'blue': 'Tesseract', 'yellow': 'Mind Stone'}
#后来雷神发现了现实宝石，让我们把它添加进去
>>> Infinity_Stones['red'] = 'Reality Stone'
>>> Infinity_Stones
{'green': 'Time Stone', 'blue': 'Tesseract', 'yellow': 'Mind Stone', 'red': 'Reality Stone'}

字典中的键是唯一的，在创建字典的时候如果有两个相同的键，最后一个键对应的值会替换前一个键对应的值：

>>> Infinity_Stones = {
... "green":"Time Stone",
... "blue":"Space Stone",
... "yellow":"Mind Stone",
... "blue":"Tesseract",
... }
>>> Infinity_Stones
{'green': 'Time Stone', 'blue': 'Tesseract', 'yellow': 'Mind Stone'}

使用update()合并字典

现在要将另一个字典与现有字典进行合并：

>>> Infinity_Stones
{'green': 'Time Stone', 'blue': 'Tesseract', 'yellow': 'Mind Stone'}
>>> others = {'yellow':'Mind Stone'}
>>> Infinity_Stones.update(others)
>>> Infinity_Stones
{'green': 'Time Stone', 'blue': 'Tesseract', 'yellow': 'Mind Stone'}
#如果要合并的字典中的键与代合并字典有相同的键，那么键对应的值会覆盖
>>> others = {'blue':'Space Stone'}
>>> Infinity_Stones.update(others)
>>> Infinity_Stones
{'green': 'Time Stone', 'blue': 'Space Stone', 'yellow': 'Mind Stone'}
#可以看到宇宙魔方被替换成了空间宝石

使用[key]获取元素

指定字典的键就可以获取对应的值：

>>> Infinity_Stones
{'green': 'Time Stone', 'blue': 'Space Stone', 'yellow': 'Mind Stone'}
>>> Infinity_Stones['blue']
'Space Stone'

r如果对应键不存在就会报错：

>>> Infinity_Stones
{'green': 'Time Stone', 'blue': 'Space Stone', 'yellow': 'Mind Stone'}
>>> Infinity_Stones['red']
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'red'

可以使用字典函数 get()。指定字典名，键以及一个可选值。如果键存在，会得到与之对应的值：

>>> Infinity_Stones.get('blue')
'Space Stone'

反之，若键不存在，如果指定了可选值，那么 get() 函数将返回这个可选值：

>>> Infinity_Stones.get('red', 'Reality Stone')
'Reality Stone'

否则，会得到 None（交互式解释器中不显示）：

>>> Infinity_Stones.get('red')
>>>
>>> print(Infinity_Stones.get('red'))
None

使用keys()获取所有键

使用 keys() 可以获得字典中的所有键。使用del删除具有指定键的元素：

>>> Infinity_Stones
{'green': 'Time Stone', 'blue': 'Space Stone', 'yellow': 'Mind Stone'}
>>> Infinity_Stones.keys()
dict_keys(['green', 'blue', 'yellow'])   #返回 dict_keys()，它是键的迭代形式。
>>> list(Infinity_Stones.keys())      # 可以用list()函数转换为列表
['green', 'blue', 'yellow']

使用values()获取所有值

使用 values() 可以获取字典中的所有值：

>>> Infinity_Stones
{'green': 'Time Stone', 'blue': 'Space Stone', 'yellow': 'Mind Stone'}
>>> list(Infinity_Stones.values())
['Time Stone', 'Space Stone', 'Mind Stone']

使用items()获取所有键值对

使用 items() 函数可以获取字典中所有的键值对：

>>> Infinity_Stones
{'green': 'Time Stone', 'blue': 'Space Stone', 'yellow': 'Mind Stone'}
>>> list(Infinity_Stones.items())
[('green', 'Time Stone'), ('blue', 'Space Stone'), ('yellow', 'Mind Stone')]
#键值对以元组的形式返回

元组赋值和复制

与列表一样，一个字典如果关联多个变量，那么字典内容改变会影响与其关联的变量：

>>> a = Infinity_Stones
>>> b = Infinity_Stones
>>> a
{'green': 'Time Stone', 'blue': 'Space Stone', 'yellow': 'Mind Stone'}
>>> b
{'green': 'Time Stone', 'blue': 'Space Stone', 'yellow': 'Mind Stone'}
>>> a['blue'] = 'Tesseract'
>>> a
{'green': 'Time Stone', 'blue': 'Tesseract', 'yellow': 'Mind Stone'}
>>> b
{'green': 'Time Stone', 'blue': 'Tesseract', 'yellow': 'Mind Stone'}
>>> Infinity_Stones
{'green': 'Time Stone', 'blue': 'Tesseract', 'yellow': 'Mind Stone'}

若想避免这种情况，可以使用 copy() 将字典复制到一个新的字典中：

>>> a = Infinity_Stones.copy()
>>> a
{'green': 'Time Stone', 'blue': 'Tesseract', 'yellow': 'Mind Stone'}
>>> b
{'green': 'Time Stone', 'blue': 'Tesseract', 'yellow': 'Mind Stone'}
>>> Infinity_Stones.copy()
{'green': 'Time Stone', 'blue': 'Tesseract', 'yellow': 'Mind Stone'}
>>> a['blue'] = 'Space Stone'
>>> a
{'green': 'Time Stone', 'blue': 'Space Stone', 'yellow': 'Mind Stone'}
>>> b
{'green': 'Time Stone', 'blue': 'Tesseract', 'yellow': 'Mind Stone'}
>>> Infinity_Stones
{'green': 'Time Stone', 'blue': 'Tesseract', 'yellow': 'Mind Stone'}

字典删除元素

使用 del 可以删除具有指定键的元素，删除全部元素可以使用 clear()，或者给字典变量重新赋值一个空字典（{}）：

>>> a
{'green': 'Time Stone', 'blue': 'Space Stone', 'yellow': 'Mind Stone'}
>>> b
{'green': 'Time Stone', 'blue': 'Tesseract', 'yellow': 'Mind Stone'}
>>> del a['blue']
>>> a
{'green': 'Time Stone', 'yellow': 'Mind Stone'}
>>> a.clear()
>>> a
{}
>>> b
{'green': 'Time Stone', 'blue': 'Tesseract', 'yellow': 'Mind Stone'}
>>> b = {}
>>> b
{}

集合

集合中的元素无序且不允许重复。如果想知道某一个元素是否存在而不关心其他的，使用集合是个非常好的选择。

使用set()创建集合

使用 set() 函数创建一个集合，或者用大括号将一系列以逗号隔开的值包裹起来，如下所示：

>>> set_test = set()
>>> set_test
set()
>>> set_test = {0,1,2,3,4,5,6}
>>> set_test
{0, 1, 2, 3, 4, 5, 6}
>>> type(set_test)   # type()可查看类型
<class 'set'>

使用set()将其他类型转换为集合

可以用已有列表、字符串、元组或字典的内容来创建集合，其中重复的值会被丢弃。首先来转换一个包含重复字母的字符串：

>>> set('apple')   #字符串
{'a', 'p', 'l', 'e'}
>>> set(['apple', 'apple', 'banana'])   #列表
{'banana', 'apple'}
>>> set(('apple', 'apple', 'banana'))   #元组
{'banana', 'apple'}
>>> set({'apple': '1', 'apple': '2', 'banana': '3'})  #字典只保留键
{'banana', 'apple'}

集合运算符

使用特殊符号 & 获取集合的交集（两集合共有元素），如下所示：

>>> a = {1, 2}
>>> b = {2, 3}
>>> a & b
{2}

使用 | 来获取集合的并集（至少出现在一个集合中的元素）：

>>> a | b
{1, 2, 3}

使用字符 - 可以获得两个集合的差集（出现在第一个集合但不出现在第二个集合）：

>>> a - b
{1}
>>> b - a
{3}

使用 ^ 可以获得两个集合的异或集（仅在两个集合中出现一次）：

>>> a ^ b
{1, 3}

使用 <= 可以判断一个集合是否是另一个集合的子集（第一个集合的所有元素都出现在第二个集合中）：

>>> a <= b
False
>>> a <= a
True
>>> b = {1, 2, 3}
>>> a = {1, 2}
>>> a <= b
True

当第二个集合包含所有第一个集合的元素，且仍包含其他元素时，我们称第一个集合为第二个集合的真子集。使用 < 可以进行判断：

>>> a < b
True
>>> a < a
False

超集与子集正好相反（第二个集合的所有元素都出现在第一个集合中），使用 >= 可以进行判断：

>>> a >= b
False
>>> a >= a   #  一个集合是它本身的超集
True

使用 > 可以找到一个集合的真超集（第一个集合包含第二个集合的所有元素且还包
含其他元素）：

>>> a = {1, 2, 3}
>>> b = {1, 2}
>>> a > b
True
>>> a > a  #  一个集合并不是它本身的真超集：
False