列表是 Python 中使用最多的一种数据类型，列表除了拥有序列通用的操作之外，还拥有很多特有的方法。

内置类 list

可以将任何序列通过 list 类转换为列表。
例如字符串，它是序列但是它不能被修改，转换为列表后就可以修改了：

1
2
3
4
5
6
str = list('Python')
str
['P', 'y', 't', 'h', 'o', 'n']
str[0] = 'C'
str
['C', 'y', 't', 'h', 'o', 'n']

可以再使用 ''.join(target_list) 来将列表转换为字符串类型：

1
2
3
4
5
6
7
type(str)
<class 'list'>
''.join(str)
'Cython'
str2 = ''.join(str)
type(str2)
<class 'str'>

列表的基本操作

除了能对列表进行标准序列的操作（索引、切片、相加、相乘），列表核心之处在于它是能够被修改的，对列表修改有多种方式。

修改列表：给元素赋值

使用索引给特定位置的元素赋值：

1
2
3
4
numbers = [4,2,3]
numbers[0] = 1
print(numbers)
[1, 2, 3]

不能给不存在的元素赋值：

1
2
3
4
5
numbers[3] = 0
Traceback (most recent call last):
  File "<pyshell#15>", line 1, in <module>
    numbers[3] = 0
IndexError: list assignment index out of range

删除元素

使用 del 删除元素：

1
2
3
4
5
numbers
[1, 2, 3]
del numbers[0]
numbers
[2, 3]

del 不返回任何数据。

给切片赋值

通过使用切片赋值，可将切片替换为长度与原先长度不同的序列，意味这可以给不存在的元素赋值。

1
2
3
4
5
numbers
[2, 3]
numbers[1:] = list('Python')
numbers
[2, 'P', 'y', 't', 'h', 'o', 'n']

切片可以在不替换原有元素的情况下插入新元素：

1
2
3
4
5
numbers
[2, 'P', 'y', 't', 'h', 'o', 'n']
numbers[3:3] = [4,5,6]
numbers
[2, 'P', 'y', 4, 5, 6, 't', 'h', 'o', 'n']

numbers[3:3] 代表从索引 3 开始插入。

解除切片赋值还可以用于删除元素：

1
2
3
4
5
numbers
[2, 'P', 'y', 4, 5, 6, 't', 'h', 'o', 'n']
numbers[3:6] = ''
numbers
[2, 'P', 'y', 't', 'h', 'o', 'n']

上述操作等同于 del numbers[3:6] 但是切片还可以支持步进。

list 方法

list 是一个标准的内置类，类中提供了一些有用的方法。
类的调用方法格式为 object.method(arguments 。

append

append 用于将一个对象附加到列表的末尾：

1
2
3
4
numbers=[1,2,3]
numbers.append(4)
numbers
[1, 2, 3, 4]

append 就地更改列表，且不会返回任何内容。

clear

clear 方法就地清空列表的内容：

1
2
3
4
5
numbers
[1, 2, 3, 4]
numbers.clear()
numbers
[]

copy

copy 方法用于复制列表：

1
2
3
4
a = [1,2,3]
b = a.copy()
b
[1, 2, 3]

不能使用 b = a ，此时 b 是指向 a 并没有创建一个新的列表。
也可以等效于：

1
b = a[:]

但是不太高效。

count

count 方法用于计算指定的元素在列表中出现的次数：

1
2
3
numbers = [1,1,1,1,2,3]
numbers.count(1)
4

extend

extend 方法能够同时将多个值附加到列表末尾，可以实现使用一个列表来扩展另一个列表：

1
2
3
4
5
a = [1,2,3]
b = [4,5,6]
a.extend(b)
a
[1, 2, 3, 4, 5, 6]

它跟序列相加非常类似，但是序列相加不会就地更改现有的列表值，必须多添加一个赋值的操作，可读性和效率没有那么好：

1
2
3
4
5
a = [1,2,3]
b = [4,5,6]
a = a + b
a
[1, 2, 3, 4, 5, 6]

index

index 方法用于在列表中查找指定的值第一次出现的索引：

1
2
3
4
numbers
[1, 1, 1, 1, 2, 3]
numbers.index(1)
0

index 方法会返回索引。同时如果查找不到将报错：

1
2
3
4
5
numbers.index('hello')
Traceback (most recent call last):
  File "<pyshell#67>", line 1, in <module>
    numbers.index('hello')
ValueError: 'hello' is not in list

insert

insert 方法用于将一个对象插入列表，需要提供索引和值：

1
2
3
4
5
numbers
[1, 1, 1, 1, 2, 3]
numbers.insert(2, 'B')
numbers
[1, 1, 'B', 1, 1, 2, 3]

前面的切片赋值也可以实现同等效果，但可读性差，推荐使用 insert 方法。

pop

pop 方法从列表中删除最后一个元素，并返回被删除的元素：

1
2
3
4
5
6
numbers
[1, 1, 'B', 1, 1, 2, 3]
numbers.pop()
3
numbers
[1, 1, 'B', 1, 1, 2]

可以结合 insert(0, VALUE) 实现先进先出（FIFO）的队列。

remove

remove 方法用于删除指定值的列表中出现的第一个元素：

1
2
3
4
5
numbers
[1, 1, 'B', 1, 1, 2]
numbers.remove(1)
numbers
[1, 'B', 1, 1, 2]

remove 方法没有返回值。

reverse

reverse 方法按照相反的顺序排列列表中的元素：

1
2
3
4
lst = list('python')
lst.reverse()
lst
['n', 'o', 'h', 't', 'y', 'p']

sort

sort 方法用于对列表就地排序：

1
2
3
4
numbers = [4,3,5,7,6,2,9,8]
numbers.sort()
numbers
[2, 3, 4, 5, 6, 7, 8, 9]

高级用法

sort 方法接受两个可选参数：

  • key 指定排序的函数
  • reverse True 或 False 是否按照相反的顺序对列表进行排序

使用 len 函数根据字符长短进行排序：

1
2
3
4
x = ['aardvark', 'abalone', 'acme', 'add', 'aerate']
x.sort(key=len)
x
['add', 'acme', 'aerate', 'abalone', 'aardvark']

使用相反的顺序进行排序：

1
2
3
4
numbers = [4,3,5,7,6,2,9,8]
numbers.sort(reverse=True)
numbers
[9, 8, 7, 6, 5, 4, 3, 2]

元组

元组也是序列的一种，但跟列表不同，元组是不能修改的。
将值用逗号分隔，就能自动创建一个元组：

1
2
3
4
5
6
7
8
9
10
11
12
a = 1,2,3
b = (1,2,3)
c = ()
d = 42,
type(a)
<class 'tuple'>
type(b)
<class 'tuple'>
type(c)
<class 'tuple'>
type(d)
<class 'tuple'>

内置类 tuple的工作原理与内置类 list 类似，将一个序列转换为元组。

1
2
3
4
5
6
a = tuple([1,2,3])
a
(1, 2, 3)
b = tuple('abc')
b
('a', 'b', 'c')

对于元组来说，除了创建和访问，可执行的其它操作不多。