由于列表过于重要，请认真看完并保证所有代码都敲过一遍。
什么是列表
列表是 Python 中最常用的数据结构，也是一种数据类型，其样式如下：
li = [1, 2, 3, 'a', 'b']
列表是一种序列。Python 中的序列有 列表 list、元组 tuple、字符串 str。
百度百科关于序列的解释：
数学上，序列是被排成一列的对象（或事件)；这样每个元素不是在其他元素之前，就是在其他元素之后。这里，元素之间的顺序非常重要。
列表是一种有序、可变的存储结构。列表中的元素可以是任意的数据类型，数量也没有限制。简单来说，列表主要用来存取数据的。比如我们从数据库或者 excel 文件中读取数据后，需要临时存储在内存中，就会使用列表。
列表操作
1. 创建列表
列表使用方括号，方括号内以逗号分隔各个元素。
>>> li = [] # 创建空列表
>>> li1 = [1,2,3,'a','b'] # 对元素的数据类型没有要求，任意组合
>>> li2 = [1,2,3,['a', 'b']] # 甚至元素本身也可以是一个列表（构成多维列表）
2. 列表取值
列表取值涉及到索引的概念，列表中每个元素都有一个索引，索引的计数从 0 开始，如列表 li = [7, 8, 9,10,11]，索引如下：
Python 中，列表的索引有正向索引（从0开始）和负向的索引（从-1开始）。上图中的 0 和 -5 代表同一个索引位置。
那么列表取值就需要用到索引：
>>> li = [7, 8, 9,10,11]
>>> li[0] # 取第一个
7
>>> li[-5] # 取倒数第5个，也就是第一个
7
>>> li[-1] # 取最后一个
11
>>> li[5] #取第5个，但是我们现在只有4个，所以报超出索引的错误
IndexError: list index out of range
如果有多维列表的话，要子列表中的元素的话，需要根据维度多次取值：
>>> li = [1,2,3,['a', 'b']] # 'b' 元素在 li 列表的子列表中
>>> li[3][1] # 先取出子列表，再取子列表中的第二个元素
'b'
# 上面的语句拆解一下
>>> sli = li[3] # 先取子列表，子列表是 li 列表的第四个元素
>>> sli
['a', 'b']
>>> sli[1] # 再从子列表中取第二个元素
'b'
注意，我们在操作列表的时候一定要注意列表的长度，否则就会出现超出索引的错误。要确定列表的最大长度，我们可以使用 len()函数。后面讲列表相关函数时一并讲解。
3. 列表改值
列表通过索引取值，也可以通过索引改值。
>>> li[0] = 77 # 修改第一个元素的值，从 7 改为 77
>>> li # 修改后要重新查看一下列表的值才能看到变化
[77, 8, 9, 10, 11]
>>> li[-2] = 110 # 也可以使用负向索引改值
>>> li
[77, 8, 9, 110, 11]
4. 列表运算
除了上面的列表取值和改值，我们也可以进行一些其他的运算。
列表相加
>>> [1, 2, 3] + [5, 7] # 两个列表相加，组合生成一个新列表
[1, 2, 3, 5, 7]
列表乘法
>>> [1, 2] * 3
[1, 2, 1, 2, 1, 2]
成员运算
>>> li = [1,2,3,['a', 'b']]
>>> 3 in li # 元素 3 是否在列表 li 中
True
>>> 'a' in li # 元素 'a' 在 li 的子列表中，不在 li 中
False
>>> ['a', 'b'] in li
True
列表常用函数
| 函数 | 说明 |
|---|---|
| len | 取列表长度，也就是列表中元素的个数 |
| max | 取列表中的最大值，要注意列表中的元素必须是能够进行比较运算的数据类型 |
| min | 取列表中的最小值，注意事项同 max |
| sorted | 对列表排序，并返回一个排好序的新列表，注意事项同 max |
# len() 函数
>>> li = [1,2,3,['a', 'b']]
>>> len(li) # 调用 len 函数，将列表变量 li 作为 len 函数的参数传入
4
# max() 函数
>>> max(li) # li 中有整型和列表两种数据类型，这两种数据类型不能进行比较运算
TypeError: '>' not supported between instances of 'list' and 'int'
>>> li1 = [3,4,8,2,5]
>>> max(li1) # 其实从上面的报错信息可以看出来，max 和 min 函数是通过比较大小后，输出一个最大/最小的值
8
# min() 函数
>>> min(li1)
2
# sorted() 函数
>>> sorted(li1)
[2, 3, 4, 5, 8]
>>> sorted(li) # sorted 函数也不允许对不同的数据类型排序，因为它也用的是比较运算
TypeError: '<' not supported between instances of 'list' and 'int'
不同的数据类型之间排序是没有意义，不用继续玩下去了 ─━ _ ─━✧（能看出是斜视么）
列表常用内置方法
这里提到了函数和方法，函数是 Python 内置的一些预设常用的函数，可以针对多种数据类型和情况进行处理。而列表的内置方法呢，只能针对列表本身，也就是把列表作为一个对象去操作了。
关于函数和方法的概念，后面会详细讲解。
| 方法 | 说明 |
|---|---|
| append(obj) | 在列表末尾添加新的元素，最常用的方法 |
| count(obj) | 统计某个元素出现的次数 |
| extend(seq) | 在列表末尾追加另一个列表（或其他序列类型） |
| index(obj) | 从列表中找到一个匹配元素的索引位置，注意只能匹配第一个 |
| insert(index, obj) | 在指定的索引位置插入元素 |
| pop(index) | 删除指定索引位置的元素，如果不传值则表示删除最后一个元素 |
| remove(obj) | 删除指定的元素；如果有多个同样的元素，删除第一个 |
| reverse() | 将列表中的元素按照索引反向排列（不是反向排序，只是按照现有的顺序反过来而已） |
| sort() | 对原列表进行排序。注意是原列表，上面讲的 sorted() 函数是返回一个排序后的新列表 |
| copy() | 将列表拷贝生成一个新的列表 |
| clear() | 清空列表 |
1. append(obj) 添加元素
在列表末尾添加新的元素，此方法是列表方法中最常用的方法。务必记住。
>>> li = [1,2,3]
>>> li.append('a') # 改变的是原列表，所以没有返回值
>>> li # 要看改动结果，需要查看原列表
[1, 2, 3, 'a']
>>> li.append(['x','y']) # 把一个列表作为元素添加到 li 列表末尾
>>> li # 生成一个二维的列表
[1, 2, 3, 'a', ['x', 'y']]
2. count(obj) 统计元素个数
在括号中输入要统计的元素，conut 方法返回该元素出现的次数。
>>> li = [1,2,3,2,5]
>>> li.count(2)
2
3. extend(seq) 追加列表（序列）
extend 方法用于将另外的序列（列表、元组或字符串）中的所有元素，追加到原列表中。与列表相加生成新列表不同，extend 改变的是原列表。
>>> li = [1,2,3]
>>> li2 = ['x', 'y']
>>> li.extend(li2)
>>> li
[1, 2, 3, 'x', 'y'] # 将 li2 中的所有元素全部追加到 li
4. index(obj) 查找元素
从列表中找到一个匹配元素的索引位置，注意只能匹配第一个，如果有多个那么也只能找到第一个。不要问我如果有多个怎么办，也许你该试试先去重。
>>> li = ['x', 'y', 'z', 'x']
>>> li.index('x')
0 # 返回索引位置
5. insert(index, obj) 插入元素
在第一个参数指定的索引位置插入元素。
>>> li = ['x', 'y', 'z', 'x']
# 我插入一个 'a' 到 'y' 和 'z' 之间。相当于在 'z' 所在的索引位置插入 'a'
>>> i = li.index('z') # 找到 z 所在的索引
>>> li.insert(i, 'a') # 也可以写在一起 li.insert(li.index('z'), 'a')
>>> li
['x', 'y', 'a', 'z', 'x']
insert 方法在列表元素较多的情况下不建议使用，因为一旦通过 insert 插入数据，列表后半部分的元素索引都会发生变化（比如上例中的 'z' 和 'x' 索引都会加 1），造成不必要的运算。
所以一般除非有必要否则都是使用 append 来添加元素。
6. pop(index)根据索引删除元素
pop 方法根据索引删除元素，也就是说删除需要删除的元素索引。
如果不指定则默认删除最后一个，这也是消耗最小的一种做法。因为删除中间位置的元素，那么也会造成后半部分元素索引的变化，会造成不必要的性能损耗。
>>> li = ['x', 'y', 'a', 'z', 'x']
>>> li.pop(2)
'a' # 返回被删除的元素
>>> li
['x', 'y', 'z', 'x']
7. remove(obj)删除指定的元素
pop 方法根据索引删除元素，如果是默认删最后一个，删除效率是最高的。而 remove 方法是指定元素删除，如果有重复的元素，则只会删除第一个。
>>> li = ['x', 'y', 'a', 'z', 'x']
>>> li.remove('x') # 你自己知道你删的是啥，所以不再需要返回删除的内容了
>>> li
['y', 'a', 'z', 'x'] # 有两个 'x'， 只删除第一个
8. reverse() 反向
将列表中的元素按照索引反向排列。
>>> li = [7, 11, 5, 3, 8]
>>> li.reverse()
>>> li
[8, 3, 5, 11, 7]
9. sort() 列表排序
对原列表进行排序。注意是原列表，上面讲的 sorted() 函数是返回一个排序后的新列表。
>>> li = [7, 11, 5, 3, 8]
>>> sorted(li)
[3, 5, 7, 8, 11] # 输出的是新的列表
>>> li
[7, 11, 5, 3, 8] # 原列表没有发生变化
>>> li.sort()
>>> li
[3, 5, 7, 8, 11] # 改变的是原来的列表
>>> lis = ['x', 'X', 'a', '5'] # 还可以对字符串排序，字符串排序是按照 ASCII 排序
# ASCII 的顺序是“数字 < 大写字母 < 小写字母”
>>> lis.sort()
>>> lis
['5', 'X', 'a', 'x']
# sort 还有一个参数 reverse，用于指定升序还是降序。默认值为 False 表示升序
# 如果要使用降序，则修改该参数值为 True
>>> li = [7, 11, 5, 3, 8]
>>> li.sort(reverse=True) # 设置降序，升序不需要传 reverse 的值
>>> li
[11, 8, 7, 5, 3]
注意，排序时，必须全部是数值类型或者字符串类型，不能混合，否则会报错。
10. copy() 拷贝列表
需要给变量赋值一个列表，可以采用直接赋值的方式。但是直接赋值代表两个变量指向同一个列表的地址，而列表又是可变的，导致一个变量变化，另一个变量也会变化。
>>> l1 = [7, 11, 5, 3, 8] # 列表 l1
>>> l2 = l1 # l1 赋值给 l2
>>> l1
[7, 11, 5, 3, 8]
>>> l2
[7, 11, 5, 3, 8]
>>> l1[1] = 1 # 修改 l1 的值，将第二个元素 11 改为 1
>>> l1
[7, 1, 5, 3, 8]
>>> l2 # l2 的值也会跟着变化
[7, 1, 5, 3, 8]
那么想复制一个列表，并且是独立的，那么需要使用 copy 方法。
>>> l1 = [7, 11, 5, 3, 8]
>>> l2 = l1.copy() # 复制
>>> l1
[7, 11, 5, 3, 8]
>>> l2
[7, 11, 5, 3, 8]
>>> l1[0] = 77 # 修改 l1 的值
>>> l1
[77, 11, 5, 3, 8]
>>> l2 # l2 并没有发生变化
[7, 11, 5, 3, 8]
当然这里只是所谓的浅复制，关于浅复制和深复制这个概念了，在面试的时候经常到，后面专门写一篇文章来说明。
11. clear() | 清空列表
这个简单，就是清空。
>>> li = [7, 11, 5, 3, 8]
>>> li.clear()
>>> li
[]
本节练习
写代码，有如下列表，按照要求实现每一个功能（每小题都使用最原始的列表）
li = ['nemo', 'nano', 'tato', 'leo', 'monkey']计算列表长度并输出 列表中追加元素 "seven"，并输出添加后的列表 请在列表的第 1 个位置插入元素 "Tony"，并输出添加后的列表 请修改列表第 2 个位置的元素为 "Kelly"，并输出修改后的列表 请删除列表中的元素 "nano"，并输出修改后的列表 请删除列表中的第 2 个元素，并输出删除的元素的值和删除元素后的列表 请删除列表中的第 3 个元素，并输出删除元素后的列表 请将列表所有的元素反转，并输出反转后的列表 找到 "leo" 元素并将其修改为 "lee"