Code Is Elegant

写优雅的代码

1432 字

7 分钟

Python-列表与元组

2023-01-17

Python

参考资料：【Python教程】《零基础入门学习Python》最新版（2022年12月26日更新）

列表#

1. 创建列表#

1
mlist = [1, 2, 3, 4, 5, 6]
2
_ = []

2. 访问列表#

1
print(mlist[0], end=" ")
2
print(mlist[-1])
3
# 1 6

1
for each in mlist:
2
  print(each, end=" ")
3
# 1 2 3 4 5 6

3. 修改列表#

3.1 通过下标索引修改

1
mlist = [1, 1, 3, 4, 5]
2
mlist[1] = 2

结果：mlist = [1, 2, 3, 4, 5]

3.2 通过切片修改

1
mlist[3:] = [2, 1]

结果：mlist = [1, 2, 3, 2, 1]

3.3 通过运算符修改

1
_1 = [1, 2]
2
_2 = [3, 4]
3
_ = _1 + _2
4
# _ = [1, 2, 3, 4]

4. 切片#

4.1 切片访问列表#

1
mlist = [1, 2, 3, 4, 5, 6]
2
mlist[2:4]
3
# [3, 4]
4
mlist[:3]
5
# [1, 2, 3]
6
mlist[2:]
7
# [3, 4, 5, 6]
8
mlist[:]
9
# [1, 2, 3, 4, 5, 6]
10
mlist[0:6:2]
11
# [1, 3, 5]
12
mlist[::-1]
13
# [6, 5, 4, 3, 2, 1]

切片访问语法：列表名[起始下标:停止下标:检索跨度]

注意：切片访问返回的是一个可迭代对象，所以切片可以实现浅拷贝

1
mlist_copy = mlist[:]

4.2 切片修改列表#

1
mlist = [1, 2, 3, 4, 5, 6]
2
mlist[len(mlist):] = [7]
3
# mlist = [1, 2, 3, 4, 5, 6, 7]
4
mlist[len(mlist):] = [8, 9]
5
# mlist = [1, 2, 3, 4, 5, 6, 7, 8, 9]

5. 函数#

函数	功能
mlist.append(an element)	将`一个元素`追加到列表mlist末尾
mlist.extend(iterable)	将`迭代结果`逐个追加到列表mlist末尾
mlist.insert(an index, an element)	将该元素`插入`到列表mlist的指定下标位置
mlist.remove(an element)	将该元素从列表mlist中`删除`，若元素不在列表内，则会报错
mlist.pop(an index)	将该下标对应元素从列表中`弹出`
mlist.clear()	将列表mlist变为`空列表`
mlist.sort(key=None, reverse=False)	将列表mlist`排序`，参数reverse控制是否`倒序`
mlist.reverse()	将列表`倒序`排列
mlist.count(an element)	返回这个元素在列表中的`个数`
mlist.index(an element, start index, end index)	返回这个元素的`下标`，若有多个则返回第一个
mlist.copy()	返回原列表的`浅拷贝`
len(mlist)	返回值等于列表mlist的`长度`

6. 嵌套列表#

初始化

1
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
2
matrix = [[1, 2, 3],
3
          [4, 5, 6],
4
          [7, 8, 9]]
5
A = [0] * 3
6
for i in range(3):
7
    A[i] = [0] * 3

注：不要这样声明嵌套列表：B = [[0] * 3] * 3

这样声明的列表其实是对同一个[0, 0, 0]引用三次

即假设 B[0][0] = 1，则B = [[1, 0, 0], [1, 0, 0], [1, 0, 0]]

1
B[0] is B[1]
2
# True

访问

1
matrix[0]
2
# [1， 2， 3]
3
matrix[0][0]
4
# 1
5
for i in matrix:
6
    for j in i:
7
        print(j, end=" ")# 空格结尾
8
    print() # 换行
9
# 1 2 3
10
# 4 5 6
11
# 7 8 9

7. 列表名与列表#

1
x = [1, 2, 3]
2
y = x
3
x is y
4
# True 说明x与y表示同一个列表

注：Python中，变量名并不是一个盒子，数据并非储存在变量中，而是变量名与数据挂钩，列表名能够引用其指向的数据

8. 列表拷贝#

在Python中，拷贝可以分为浅拷贝和深拷贝

在嵌套结构中，对其中所嵌套元素，浅拷贝仅拷贝其引用，而深拷贝会将嵌套元素也拷贝

1
mlist = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
2
import copy # 深拷贝所在库
3
mlist_copy1 = mlist # 引用赋值（非拷贝，mlist_copy1 与 mlist 指向同一对象）
4
mlist_copy2 = copy.copy(mlist) # 浅拷贝
5
mlist_copy3 = copy.deepcopy(mlist) # 深拷贝

9. 列表推导式#

语法：

基本形式：_ = [expression for target in iterable]

筛选形式：_ = [expression for target in iterable if condition]

完整形式：

1
_ = [expression for target1 in iterable1 if condition1
2
                for target2 in iterable2 if condition2
3
                                 ...
4
                for target3 in iterable3 if condition3]

等价于：

1
_ = []
2
for target1 in iterable1:
3
    if condition1:
4
        for target2 in iterable2:
5
            if condition2:
6
                ...
7
                    _ = expression

示例 1.

1
mlist = [1, 2, 3, 4, 5]
2
mlist = [i * 2 for i in mlist]
3
# mlist = [2, 4, 6, 8, 10]

1
mlist = [char * 2 for char in "Momoyeyu"]
2
# mlist = ['MM', 'oo', 'mm', 'oo', 'yy', 'ee', 'yy', 'uu']

1
matrix = [[1, 2, 3],
2
          [4, 5, 6],
3
          [7, 8, 9]]
4
diag = [matrix[i][i] for i in range(len(matrix))]
5
# diag = [1, 5, 9]

1
matrix = [[1, 2, 3],
2
          [4, 5, 6],
3
          [7, 8, 9]]
4
flatten = [col for row in matrix for col in row]
5
# flatten = [1, 2, 3, 4, 5, 6, 7, 8, 9]

等价于：

1
flatten = []
2
for row in matrix:
3
    for col in row:
4
        flatten.append(col)

1
_ = [[x, y] for x in range(10) if x % 2 == 0 for y in range(10) if y % 3 == 0]
2
# _ = [[0, 0], [0, 3], [0, 6], [0, 9], [2, 0], [2, 3], [2, 6], [2, 9], [4, 0], [4, 3], [4, 6], [4, 9], [6, 0], [6, 3], [6, 6], [6, 9], [8, 0], [8, 3], [8, 6], [8, 9]]

等价于：

1
_ = []
2
for x in range(10):
3
    if x % 2 == 0:
4
        for y in range(10):
5
            if y % 3 == 0:
6
                _.append([x, y])

元组#

许多部分与列表相似，因此不多赘述，没有提到的部分基本都可以参考列表进行操作

1. 创建与访问元组#

创建：

1
_1 = (1, 2, 3, 4, 5)
2
_2 = 1, 2, 3, 4, 5
3
_1 == _2 # True
4
_1 is _2 # False

注：建立元组可以省略小括号，但一定需要加逗号

1
x = 1
2
type(x) # <class 'int'>
3
y = 1,
4
type(y) # <class 'tuple'>

访问：与访问列表基本一致

2. 元组的修改#

元组不可修改，指的是元组中每个元素的指向永远不变，但元素指向的数据可以发生改变

1
_ = (1, 2, 3 , 4, 5)
2
_[0] = 0
3
# Traceback (most recent call last):
4
#   File "<pyshell#9>", line 1, in <module>
5
#     _[0] = 0
6
# TypeError: 'tuple' object does not support item assignment

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

3. 解包操作#

列表，元组，字符串都可以使用解包操作

1
t = (1, 2, 3)
2
x, y, z = t
3
# x = 1; y = 2; z = 3

1
x, y, z = "Momoyeyu"
2
# Error 左侧变量名和右侧元素数量不等
3
x, y, *z = "Momoyeyu"
4
# x = M; y = o; z = "moyeyu"

Python的多重赋值本质就是先将值包装为元组，再解包与各个变量名挂钩

1
x, y = 1, 2

等价于：

1
_ = (1, 2)
2
x, y = _

Python-字符串