28.Python list列表详解

在实际开发中，经常需要将一些（不只一个）数据暂储起来，以便将来使用。说到这里，一些读者可能知道或听说过数组，它就可以把多个数据挨个存储到一起，通过数组下标可以访问数组中的各个元素。但使用数组存储数据有一个弊端，就是所存储的数据必须类型一致。

需要明确的是，Python 中没有数组，但是加入了更加强大的列表。如果把数组看做是一个集装箱，那么 Python 的列表就是一个工厂的仓库。

从形式上看，列表会将所有元素都放在一对中括号 [] 中，相邻元素之间用逗号分隔，如下所示：

[element1,element2,element3,...,elementn]

格式中，element1~elementn 表示列表中的元素，个数没有限制，只要是 Python 支持的数据类型就可以。

从内容上看，列表可以存储整数、实数、字符串、列表、元组等任何类型的数据，并且和数组不同的是，在同一个列表中元素的类型也可以不同。比如说：

["c.biancheng.net" , 1 , [2,3,4] , 3.0]

可以看到，列表中同时包含字符串、整数、列表、浮点数这些数据类型。

注意，在使用列表时，虽然可以将不同类型的数据放入到同一个列表中，但通常情况下不这么做，同一列表中只放入同一类型的数据，这样可以提高程序的可读性。

另外，在其它 Python 教程中，经常用 list 代指列表，这是因为列表的数据类型就是 list，通过 type() 函数就可以知道，例如：

>>> type(["c.biancheng.net" , 1 , [2,3,4] , 3.0])
<class 'list'>

可以看到，它的数据类型为 list，就表示它是一个列表。

Python创建列表

在 Python 中，创建列表的方法可分为 2 种，下面分别进行介绍。

使用 = 运算符直接创建列表

和其他类型的 Python 变量一样，创建列表时，也可以使用赋值运算符“=”直接将一个列表赋值给变量，其语法格式如下：

listname = [element1 , element2 , element3 , ... , elementn]

其中，listname 表示列表的名称，注意，在命名时既要符合 Python 命名规范，也要尽量避开与 Python 的内置函数重名。

例如，下面定义的列表都是合法的：

1. num = [1,2,3,4,5,6,7]
2. name = ["C语言中文网","http://c.biancheng.net"]
3. program = ["C语言","Python","Java"]

另外，使用此方式创建列表时，列表中元素可以有多个，也可以一个都没有，例如：

emptylist = []

这表明，emptylist 是一个空列表。

使用list()函数创建列表

除使用前面介绍的方括号语法创建列表之外，Python 还提供了一个内置的 list() 函数来创建列表，它可用于将元组、区间（range）等对象转换为列表，例如：

1. a_tuple = ('crazyit', 20, -1.2)
2. # 将元组转换成列表
3. a_list = list(a_tuple)
4. print(a_list)

输出结果为：

['crazyit', 20, -1.2]

此程序的功能是将一个元组 ('crazyit', 20, -1.2) 转换成列表。由于尚未学习元组，因此初学者只需要知道，用圆括号 () 括起来的多个数据，就是一个元组。

再举个例子：

1. # 使用range()函数创建区间（range）对象
2. a_range = range(1, 5)
3. # 将区间转换成列表
4. b_list = list(a_range)
5. print(b_list)

输出结果为：

[1, 2, 3, 4]

程序中，range(1,5) 函数的功能是生成从 1（包括 1）到 5（不包括 5）之间的整数，也就是 1、2、3、4。

有关 range() 函数的具体用法，后续章节会作详细介绍。

访问列表元素

在 Python 中，如果想将列表的内容输出也比较简单，直接使用 print() 函数即可。例如，前面已经创建了一个名为 name 的列表，输出此列表的执行代码如下：

1. name = ["C语言中文网","http://c.biancheng.net"]
2. print(name)

运行结果为：

['C语言中文网', 'http://c.biancheng.net']

可以看到，输出整个列表时，是包括左右两侧的中括号的。

如果不想要输出全部的元素，可以通过列表的索引获取指定的元素。例如，获取 name 列表中索引值为 1 的元素，可以使用如下代码：

1. name = ["C语言中文网","http://c.biancheng.net"]
2. print(name[1])

运行结果为：

http://c.biancheng.net

从执行结果可以看出，在输出单个列表元素时，是不带中括号的，且如果是字符串，还不包括左右的引号。

除了一次性访问列表中的单个元素外，列表还可以通过切片操作实现一次性访问多个元素。

有关切片操作的具体格式，可阅读《Python序列详解》一节，这里不再赘述。

例如：

1. num = [1,2,3,4,5,6,7]
2. print(num[2:4])

输出结果为：

[3, 4]

可以看到，通过切片操作，最终得到的是一个新的列表。

Python删除列表

对于已经创建的列表，如果不再使用，可以使用 del 语句将其删除。

实际开始时，del 语句不常用，因为 Python 自带的垃圾回收机制会自动销毁不用的列表，所以即使开发者不手动将其删除，Python 也会自动将其回收。

del 的语法格式为：

del listname

其中，listname 表示要删除列表的名称。

例如，删除前面创建的 name 列表，可以使用下面的代码：

1. name = name = ["C语言中文网","http://c.biancheng.net"]
2. print(name)
3. del name
4. print(name)

运行结果为：

['C语言中文网', 'http://c.biancheng.net']
Traceback (most recent call last):
  File "C:UsersmengmaDesktop1.py", line 4, in <module>
    print(name)
NameError: name 'name' is not defined

 

Python list列表添加元素的3种方法

实际开发中，经常需要对列表进行更新，包括向列表中添加元素、修改表中元素以及删除元素。本节先来学习如何向列表中添加元素。

通过前面的学习我们知道，通过使用“+”运算符可以将多个序列进行连接，列表也不例外，例如：

1. name = ["C语言中文网"]
2. address = ["http://c.biancheng.net"]
3. print(name+address)

运行结果为：

['C语言中文网', 'http://c.biancheng.net']

可以看到，使用“+”运算符，确实可以像列表中添加元素。但是这种方式的执行效率并不高，更建议大家使用列表提供的 append() 方法。

Python append()方法添加元素

append() 方法用于在列表的末尾追加元素，该方法的语法格式如下：

listname.append(obj)

其中，listname 指的是要添加元素的列表；obj 表示到添加到列表末尾的数据，它可以是单个元素，也可以是列表、元组等。

例如：

1. a_list = ['crazyit', 20, -2]
2. # 追加元素
3. a_list.append('fkit')
4. print(a_list)
5. a_tuple = (3.4, 5.6)
6. # 追加元组，元组被当成一个元素
7. a_list.append(a_tuple)
8. print(a_list)
9. # 追加列表，列表被当成一个元素
10. a_list.append(['a', 'b'])
11. print(a_list)

运行结果为：

['crazyit', 20, -2, 'fkit']
['crazyit', 20, -2, 'fkit', (3.4, 5.6)]
['crazyit', 20, -2, 'fkit', (3.4, 5.6), ['a', 'b']]

可以看到，即便给 append() 方法传递列表或者元组，此方法也只会将其视为一个元素，直接添加到列表中，从而形成包含列表和元组的新列表。

Python extend()方法添加元素

当然，如果希望不将被追加的列表或元组当成一个整体，而是只追加列表中的元素，则可使用列表提供的 extend() 方法。

extend()方法的语法格式如下：

listname.extend(obj)

例如：

1. b_list = ['a', 30]
2. # 追加元组中的所有元素
3. b_list.extend((-2, 3.1))
4. print(b_list)
5. # 追加列表中的所有元素
6. b_list.extend(['C', 'R', 'A'])
7. print(b_list)
8. # 追加区间中的所有元素
9. b_list.extend(range(97, 100))
10. print(b_list)

运行结果为：

['a', 30, -2, 3.1]
['a', 30, -2, 3.1, 'C', 'R', 'A']
['a', 30, -2, 3.1, 'C', 'R', 'A', 97, 98, 99]

Python insert()方法插入元素

如果希望在列表中间增加元素，则可使用列表的 insert() 方法，此方法的语法格式为：

listname.insert(index , obj)

其中，index 参数指的是将元素插入到列表中指定位置处的索引值。

使用 insert() 方法向列表中插入元素，和 append() 方法一样，无论插入的对象是列表还是元组，都只会将其整体视为一个元素。

例如：

纯文本复制

1. c_list = list(range(1, 6))
2. print(c_list)
3. # 在索引3处插入字符串
4. c_list.insert(3, 'CRAZY' )
5. print(c_list)
6. # 在索引3处插入列表
7. c_list.insert(3, ["crazy"])
8. print(c_list)

输出结果为：

[1, 2, 3, 4, 5]
[1, 2, 3, 'CRAZY', 4, 5]
[1, 2, 3, ['crazy'], 'CRAZY', 4, 5]

注意，insert() 主要用来插入元素，当向列表末尾添加元素时，还是应该使用 append() 方法。

Python list列表删除元素（3种方法）

在列表中删除元素，主要分为以下 3 种应用场景：

1. 根据目标元素所在位置的索引值进行删除，可使用 del 语句；
2. 根据元素的值进行删除，可使用列表（list类型）提供的 remove() 方法；
3. 将列表中所有元素全部删除，可使用列表（list类型）提供的 clear() 方法。

根据索引值删除元素

删除列表中指定元素，和删除列表类似，也可以使用 del 语句实现。

del 语句是 Python 中专门用于执行删除操作的语句，不仅可用于删除列表的元素，也可用于删除变量等。

例如，定义一个保存 3 个元素的列表，若指定删除最后一个元素，可以使用如下的代码：

1. a_list=[20,2.4,(3,4)]
2. del a_list[-1]
3. print(a_list)

输出结果为:

[20, 2.4]

不仅如此，del 语句还可以直接删除列表的中间一段。例如如下代码：

1. a_list = ['crazyit', 20, -2.4, (3, 4), 'fkit']
2. # 删除第2个到第4个（不包含）元素
3. del a_list[1: 3]
4. print(a_list)

输出结果为：

['crazyit', (3, 4), 'fkit']

根据元素值进行删除

除使用 del 语句之外，Python 还提供了 remove() 方法来删除列表元素，该方法并不是根据索引来删除元素的，而是根据元素本身的值来执行删除操作的。

remove() 方法会删除第一个和指定值相同的元素，如果找不到该元素，该方法将会引发 ValueError 错误。

如下代码示范了使用 remove() 方法删除元素：

1. c_list = [20, 'crazyit', 30, -4, 'crazyit', 3.4]
2. # 删除第一次找到的30
3. c_list.remove(30)
4. print(c_list)
5. # 删除第一次找到的'crazyit'
6. c_list.remove('crazyit')
7. print(c_list)
8. #再次尝试删除 30，会引发 ValueEroor 错误
9. c_list.remove(30)

输出结果为:

[20, 'crazyit', -4, 'crazyit', 3.4]
[20, -4, 'crazyit', 3.4]
Traceback (most recent call last):
  File "C:UsersmengmaDesktop1.py", line 9, in <module>
    c_list.remove(30)
ValueError: list.remove(x): x not in list

在使用 remove() 方法删除列表元素之前，最好提前判断一下指定的元素是否存在，所以此方法常与 count() 方法组合使用。

删除列表所有元素

list 列表还包含一个 clear() 方法，正如它的名字所暗示的，该方法用于清空列表的所有元素。例如如下代码：

1. c_list = [20, 'crazyit', 30, -4, 'crazyit', 3.4]
2. c_list.clear()
3. print(c_list)

输出结果为:

[]

Python list列表修改元素（入门必读）

列表的元素相当于变量，因此程序可以对列表的元素赋值，这样即可修改列表的元素。例如如下代码：

1. a_list = [2, 4, -3.4, 'crazyit', 23]
2. # 对第3个元素赋值
3. a_list[2] = 'fkit'
4. print(a_list) # [2, 4, 'fkit', 'crazyit', 23]
5. # 对倒数第2个元素赋值
6. a_list[-2] = 9527
7. print(a_list) # [2, 4, 'fkit', 9527, 23]

上面代码通过索引到列表元素赋值，程序既可使用正数索引，也可使用负数索引，这都没有问题。

此外，程序也可通过 slice 语法对列表其中一部分赋值。在执行这个操作时，并不要求新赋值的元素个数与原来的元素个数相等。这意味着通过这种方式既可为列表增加元素，也可为列表删除元素。

例如，如下代码示范了对列表中间一段赋值：

1. b_list = list(range(1, 5))
2. print(b_list)
3. # 将第2个到第4个（不包含）元素赋值为新列表的元素
4. b_list[1: 3] = ['a', 'b']
5. print(b_list) # [1, 'a', 'b', 4]

如果对列表中空的 slice 赋值，就变成了为列表插入元素。例如如下代码：

1. # 将第3个到第3个（不包含）元素赋值为新列表的元素，就是插入
2. b_list[2: 2] = ['x', 'y']
3. print(b_list) # [1, 'a', 'x', 'y', 'b', 4]

如果将列表其中一段赋值为空列表，就变成了从列表中删除元素。例如如下代码：

1. # 将第3个到第6个（不包含）元素赋值为空列表，就是删除
2. b_list[2: 5] = []
3. print(b_list) # [1, 'a', 4]

对列表使用 slice 语法赋值时，不能使用单个值；如果使用字符串赋值，Python 会自动把字符串当成序列处理，其中每个字符都是一个元素。例如如下代码：

1. # Python会自动将str分解成序列
2. b_list[1: 3] = 'Charlie'
3. print(b_list) # [1, 'C', 'h', 'a', 'r', 'l', 'i', 'e']

在使用 slice 语法赋值时，也可指定 step 参数。但如果指定了 step 参数，则要求所赋值的列表元素个数与所替换的列表元素个数相等。例如如下代码：

纯文本复制

1. c_list = list(range(1, 10))
2. # 指定step为2，被赋值的元素有4个，因此用于赋值的列表也必须有4个元素
3. c_list[2: 9: 2] = ['a', 'b', 'c', 'd']
4. print(c_list) # [1, 2, 'a', 4, 'b', 6, 'c', 8, 'd']

Python list常用方法（count、index、pop、reverse和sort）快速攻略

除前面章节介绍的增加元素、删除元素、修改元素方法之外，列表还包含了一些常用的方法。

例如，在交互式解释器中输入 dir(list) 即可看到列表包含的所有方法，如下所示：

>>> dir(list)
['append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
>>>

在上面输出结果中己经剔除了那些以双下画线开头的方法。按照约定，这些方法都具有特殊的意义，不希望被用户直接调用。

上面有些方法前面己经介绍过了，接下来给大家介绍另外的一些常用方法。

count()方法

此方法用于统计列表中某个元素出现的次数，其基本语法格式为：

listname.count(obj)

其中，listname 代表列表名，obj 表示判断是否存在的元素。

下面代码示范了 count() 方法的用法：

1. a_list = [2, 30, 'a', [5, 30], 30]
2. # 计算列表中30的出现次数
3. print(a_list.count(30))
4. # 计算列表中[5, 30]的出现次数
5. print(a_list.count([5, 30]))

运行结果为：

2
1

index()用法

index() 方法用于定位某个元素在列表中出现的位置（也就是索引），如果该元素没有出现，则会引发 ValueError 错误。

此方法的基本语法格式为：

listname.index(obj,start,end)

同 count() 方法不同，index() 方法还可传入 start、end 参数，用于在列表的指定范围内搜索元素。

如下代码示范了 index() 方法的用法：

1. a_list = [2, 30, 'a', 'b', 'crazyit', 30]
2. # 定位元素30的出现位置
3. print(a_list.index(30))
4. # 从索引2处开始、定位元素30的出现位置
5. print(a_list.index(30, 2))
6. # 从索引2处到索引4处之间定位元素30的出现位置，因为找不到该元素，会引发 ValueError 错误
7. print(a_list.index(30, 2, 4))

运行结果为：

1
5
Traceback (most recent call last):
  File "C:UsersmengmaDesktop1.py", line 7, in <module>
    print(a_list.index(30, 2, 4)) # ValueError
ValueError: 30 is not in list

pop()用法

pop() 方法会移除列表中指定索引处的元素，如果不指定，默认会移除列表中最后一个元素。该方法的基本语法格式为：

listname.pop(index)

例如：

1. a_list=[1,2,3]
2. #移除列表的元素 3
3. print(a_list.pop())
4. print(a_list)
5. #移除列表中索引为 0 的元素1
6. print(a_list.pop(0))
7. print(a_list)

运行结果为:

3
[1, 2]
1
[2]

注意，使用 pop() 方法可以实现一种常见的数据结构——栈。栈是一种特殊的数据结构，它可实现先入后出（FILO）功能，即先加入栈的元素，反而后出栈。

在其他编程语言所实现的“栈”中，往往会提供一个 push() 方法，用于实现入栈操作，但 Python 的列表并没有提供 push() 方法，我们可以使用 append() 方法来代替 push() 方法实现入栈操作。

下面代码示范了使用列表作为“栈”的示例：

1. stack = []
2. # 向栈中“入栈”3个元素
3. stack.append("fkit")
4. stack.append("crazyit")
5. stack.append("Charlie")
6. print(stack) # ['fkit', 'crazyit', 'Charlie']
7. # 第一次出栈：最后入栈的元素被移出栈
8. print(stack.pop())
9. print(stack) # ['fkit', 'crazyit']
10. # 再次出栈
11. print(stack.pop())
12. print(stack) # ['fkit']

运行结果为：

['fkit', 'crazyit', 'Charlie']
Charlie
['fkit', 'crazyit']
crazyit
['fkit']

上面程序中，第 8 行实现了第一次出栈操作，该操作将会把最后一次添加的元素移出栈，且该方法会返回出栈的元素。因此，执行这行代码将会看到输出 Charlie。

与所有编程语言类似的是，出栈操作既会移出列表的最后一个元素，也会返回被移出的元素。

reverse()用法

reverse() 方法会将列表中所有元素反向存放。该方法的基本语法格式为：

listname.reverse()

例如：

1. a_list = list(range(1, 8))
2. # 将a_list列表元素反转
3. a_list.reverse()
4. print(a_list)

运行结果为：

[7, 6, 5, 4, 3, 2, 1]

从上面的运行结果可以看出，调用 reverse() 方法将反转列表中的所有元素。

sort()用法

sort() 方法用于对列表元素进行排序，排序后原列表中的元素顺序会方发生改变。sort() 方法的语法格式如下：

listname.sort(key=None, reserse=False)

可以看到，和其他方法不同，此方法中多了 2 个参数，它们的作用分别是：

• key 参数用于指定从每个元素中提取一个用于比较的键。例如，使用此方法时设置 key=str.lower 表示在排序时不区分字母大小写。
• reverse 参数用于设置是否需要反转排序，默认 False 表示从小到大排序；如果将该参数设为 True，将会改为从大到小排序。

例如如下代码：

1. a_list = [3, 4, -2, -30, 14, 9.3, 3.4]
2. # 对列表元素排序
3. a_list.sort()
4. print(a_list)
5. b_list = ['Python', 'Swift', 'Ruby', 'Go', 'Kotlin', 'Erlang']
6. # 对列表元素排序：默认按字符串包含的字符的编码大小比较
7. b_list.sort()
8. print(b_list) # ['Erlang', 'Go', 'Kotlin', 'Python', 'Ruby', 'Swift']

运行结果为：

[-30, -2, 3, 3.4, 4, 9.3, 14]
['Erlang', 'Go', 'Kotlin', 'Python', 'Ruby', 'Swift']

如下代码示范了 key 和 reverse 参数的用法：

1. b_list = ['Python', 'Swift', 'Ruby', 'Go', 'Kotlin', 'Erlang']
2. # 指定key为len，指定使用len函数对集合元素生成比较的键，也就是按字符串的长度比较大小
3. b_list.sort(key=len)
4. print(b_list)
5. # 指定反向排序
6. b_list.sort(key=len, reverse=True)
7. print(b_list)

运行结果为：

['Go', 'Ruby', 'Swift', 'Python', 'Kotlin', 'Erlang']
['Python', 'Kotlin', 'Erlang', 'Swift', 'Ruby', 'Go']

上面两次排序时都将 key 参数指定为 len，这意味着程序将会使用 len() 函数对集合元素生成比较大小的键，即根据集合元素的字符串长度比较大小。

注意，采用 sort() 方法对列表进行排序时，对中文支持不好，其排序结果与常用的音序排序法或者笔画排序法都不一致，因此，如果需要实现对中文内容的列表排序，还需要重新编写相应的方法进行处理，而不能直接使用 sort() 方法。

除此之外，需要指出的是，在 Python 2.x 中，列表的 sort() 方法还可传入一个比较大小的函数，该函数负责比较列表元素的大小。该函数包含两个参数，当该函数返回正整数时，代表该函数的第一个参数大于第二个参数；当该函数返回负整数时，代表该函数的第一个参数小于第二个参数；返回 0，则意味着两个参数相等。

下面代码示范了使用比较函数调用 sort() 方法。以下代码只能在 Python 2.x 中执行：

纯文本复制

1. # 以下代码只能在Python 2.x中执行
2. # 定义一个根据长度比较大小的比较函数
3. def len_cmp(x, y):
4. # 下面代码比较大小的逻辑是：长度大的字符串就算更大
5. return 1 if len(x) > len(y) else (-1 if len(x) < len(y) else 0)
6. b_list = ['Python', 'Swift', 'Ruby', 'Go', 'Kotlin', 'Erlang']
7. b_list.sort(len_cmp)
8. print(b_list)

运行结果为：

['Go', 'Ruby', 'Swift', 'Erlang', 'Kotlin', 'Python']