1. 列表

列表是有序集合对象类型，可以包含任何种类的对象，且每一项都保持了从左到右的位置顺序。

Python 列表是：

• 任意对象的有序集合
• 通过偏移读取
• 可变长度、异构以及任意嵌套
• 属于可变序列的分类
• 对象引用数组

常用列表常量和操作

操作	解释
L = []	一个空的列表
L = [123, 'abc', 1.23, {}]	四项，索引为0到3
L = ['abc', ['def', 'ghi']]	嵌套的子列表
L = list('spam')	可迭代项目的列表
L = list(range(-4, 4))	连续整数的列表
L[i]	索引
L[i][j]	索引的索引
L[i:j]	分片
len(L)	求长度
L1 + L2	合并
L * 3	重复
for x in L: print(x)	迭代
3 in L	成员关系
L.append(4)	增加
L.extend([5,6,7])
L.insert(I, X)
L.index(X)	搜索
L.count(X)
L.sort()	排序
L.reverse()	反转
L.copy()
L.clear()
L.pop(i)	缩短
L.remove(X)
del L[i]
del L[i:j]
L[i:j] = []
L[i] = 3	索引赋值
L[i:j] = [4,5,6]	分片赋值
L = [x**2 for x in range(5)	列表解析
list(map(ord, 'spam'))

2. 实际应用中的列表

2.1 基本列表操作

len([1, 2, 3])                  # 长度

3

[1, 2, 3] + [4, 5, 6]           # 合并

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

['Ni!'] * 4                     # 重复

['Ni!', 'Ni!', 'Ni!', 'Ni!']

列表中“+”操作两边必须是相同类型的序列。

[1, 2] + list('34')

[1, 2, '3', '4']

2.2 列表迭代和解析

3 in [1, 2, 3]              # 成员关系

True

for x in [1, 2, 3]:         # 迭代
    print(x, end = '')

123

[c * 4 for c in 'SPAM']     # 列表解析

['SSSS', 'PPPP', 'AAAA', 'MMMM']

2.3 索引、分片和矩阵

L = ['spam', 'Spam', 'SPAM!']
print(L[2])                 # 偏移从 0 开始
print(L[-2])                # 负偏移，从右开始
print(L[1:])

SPAM!
Spam
['Spam', 'SPAM!']

matrix = [1, 2, 3], [4, 5, 6], [7, 8, 9](1, 2, 3], [4, 5, 6], [7, 8, 9)

print(matrix[1])
print(matrix[1][1])
print(matrix[2][0])

[4, 5, 6]
5
7

2.4 原处修改列表

直接修改列表对象，不会建立新的拷贝。

索引与分片赋值

L = ['spam', 'Spam', 'SPAM!']
L[1] = 'eggs'                           #索引赋值
L

['spam', 'eggs', 'SPAM!']

L[0:2] = ['eat', 'more']                #分片赋值：删除+插入，替换0,1项
L

['eat', 'more', 'SPAM!']

L[1:2] = ['aaa', 'bbb']
L

['eat', 'aaa', 'bbb', 'SPAM!']

L = [1, 2, 3]
L[1:1] = [6, 7]              # 插入（什么也不替换）
L

[1, 6, 7, 2, 3]

L[1:2] = []                  # 删除（什么也不插入）
L

[1, 7, 2, 3]

分片赋值一次性替换整个片段或“栏”，因为被赋值的序列长度不一定要与被赋值的分片的长度相匹配，所以分片赋值能够用来替换（覆盖）、增长（插入）、缩短（删除）主列表。

L = [1]
L[:0] = [2, 3, 4]                    # 在 0 处插入所有项，头部空分片
L

[2, 3, 4, 1]

L[len(L):] = [5, 6, 7]               #在 len(L) 处插入所有项，尾部空分片
L

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

L.extend([8, 9, 10])                 #在尾部插入所有项，方法调用
L

[2, 3, 4, 1, 5, 6, 7, 8, 9, 10]

列表方法调用

L = ['spam', 'Spam', 'SPAM!']      # append 将一个单项加至列表末端
L.append('please')
L

['spam', 'Spam', 'SPAM!', 'please']

L.sort()                           # 递增顺序排序（'S'<'e'）
L

['SPAM!', 'Spam', 'please', 'spam']

L = ['abc', 'ABD', 'aBe']
sorted(L, key = str.lower, reverse = True)      # 可以传入关键字参数
L

['abc', 'ABD', 'aBe']

L = [1, 2]
L.extend([3, 4, 5])        # 在末端添加多个项
L

[1, 2, 3, 4, 5]

L.pop()                    # 删除并且返回最后一项，也能接受某一个即将删除并返回的元素的偏移

5

L

[1, 2, 3, 4]

L.reverse()                # 原地反转方法
list(reversed(L))
L

[4, 3, 2, 1]

L.index(1)                 # 某项的索引

3

L.insert(1,5)              # 在位置上插入
L

[4, 5, 3, 2, 1]

L.remove(2)                # 按值删除
L

[4, 5, 3, 1]

L.pop(0)                   # 按位删除
L

[5, 3, 1]

L.count(1)                 # 出现的次数

1

其他常见列表操作

L = ['SPAM!', 'eat', 'more', 'please']
del L[0]                   # 删除一项
L

['eat', 'more', 'please']

del L[1:]              # 和 L[1:] = [] 结果一样
L

['eat']