Python 极简教程（七）列表 list

由于列表过于重要，请认真看完并保证所有代码都敲过一遍。

什么是列表

列表是 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"