1-5-列表

发表于 更新于

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 基本列表操作

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

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

1
['Ni!'] * 4                     # 重复
['Ni!', 'Ni!', 'Ni!', 'Ni!']

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

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

2.2 列表迭代和解析

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

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

1
[c * 4 for c in 'SPAM']     # 列表解析
['SSSS', 'PPPP', 'AAAA', 'MMMM']

2.3 索引、分片和矩阵

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

1
2
3
4
5
matrix = [[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 原处修改列表

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

索引与分片赋值

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

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

1
2
L[1:2] = ['aaa', 'bbb']
L
['eat', 'aaa', 'bbb', 'SPAM!']

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

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

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

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

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

1
2
L.extend([8, 9, 10])                 #在尾部插入所有项，方法调用
L
[2, 3, 4, 1, 5, 6, 7, 8, 9, 10]

列表方法调用

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

1
2
L.sort()                           # 递增顺序排序（'S'<'e'）
L
['SPAM!', 'Spam', 'please', 'spam']

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

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

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

1
L
[1, 2, 3, 4]

1
2
3
L.reverse()                # 原地反转方法
list(reversed(L))
L
[4, 3, 2, 1]

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

1
2
L.insert(1,5)              # 在位置上插入
L
[4, 5, 3, 2, 1]

1
2
L.remove(2)                # 按值删除
L
[4, 5, 3, 1]

1
2
L.pop(0)                   # 按位删除
L
[5, 3, 1]

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

其他常见列表操作

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

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

1