Python列表练习 python列表基础

文章目录

• 列表（list）

• 一、列表的创建
• 二、列表的索引和切片
• 三、列表拼接(+)、重复拼接列表(*)
• 四、计算列表长度：len()
• 五、列表的的增删改查

• 5.1.增(增加)

• 方法一：[start : end : step]：索引赋值
• 方法二：append()：追加末尾
• 方法三：inserter()：指定位置插入
• 方法四：extend()：合并两个列表(在末尾添加)
• 方法五：合并两个列表(s += t)

• 5.2.删(删除)

• 方法一：删除元素：[start : end] = []
• 方法二：清空列表：[:]
• 方法三：删除末尾元素 pop()
• 方法四：删除指定元素 pop(index)
• 方法五：移除具体元素 remove()
• 方法六：清空列表 clear()
• 方法七：删除某个或多个元素：del list[index : end : step]
• 方法八：删除整个列表：del list

• 5.3.改(修改)

• 方法一：修改单个元素(索引赋值)
• 方法二：修改区间内的元素(切片赋值)

• 5.4.查(查询)

• index()：查找元素的下标
• count()：统计指定元素在列表出现的次数
• in，not in：查询是否存在于列表中
• for循环、for迭代

• 六、复制列表

• 1.序列复制n次：s *= n
• 2.切片赋值给新列表（浅层复制）——只复制第一层，其它层引用原来的
• 3.浅层复制：list.copy()——只复制第一层，其它层引用原来的
• 4.深层复制：直接赋值给新的列表、copy.deepcopy(x)

• 七、队列与堆栈

• 1.队列：
• 2.堆栈

• 八、压缩两个列表(了解)

• zip([iterable, ...])：返回元组列表

• 九、列表的推导式
• 十、嵌套列表、多维列表

• 1.嵌套列表和多维列表
• 2.多维列表
• 3.多维列表转换为一维列表

• 十一、排序

• 1.升序排列：sort()
• 2.降序排列：sort(reverse=True)
• 3.翻(反)转列表：reverse()

---

列表（list）

列表是python的基础数据类型之⼀ ,其他编程语⾔也有类似的数据类型. 比如JS中的数组, java中的数组等等. 它是以[ ]括起来, 每个元素⽤’ , '隔开,⽽且可以存放各种数据类型。

---

提示：以下是本篇文章正文内容，由小编进行网络整理，版权归原作者所有，如有侵权，请联系本人，本人会第一时间删除处理！

一、列表的创建

1. 方法一：列表可以由圆括号括起、逗号分隔的一组值（元素）得到。

nlist = [1, 4, 9, 16, 25]

2. 方法二：转化为列表

# 创建空列表
none_list = list()  # []
# 其它数据类型转换为列表
str_list = list('Python') # ['P', 'y', 't', 'h', 'o', 'n']

• range()：随机生成一个整数列表

l1 = list(range(10))  # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
l2 = list(range(1, 8))  # [1, 2, 3, 4, 5, 6, 7]
l3 = list(range(0, 30, 5))  # [0, 5, 10, 15, 20, 25]
l4 = list(range(0, 10, 3))  # [0, 3, 6, 9]
l5 = list(range(0))  # []
l6 = list(range(1, 0))  # []

3. 方法三：列表推导式

slist = [i for i in range(1, 5)] # [1,2,3,4]

二、列表的索引和切片

squares = [1, 4, 9, 16, 25]

# 截取单个元素
print(squares[0])  # 1
print(squares[-1])  # 25
# 截取多个元素：切片
print(squares[-3:]) # [9, 16, 25]
print(squares[:-1]) # [1, 4, 9, 16]
print(squares[::2]) # [1, 9, 25]

三、列表拼接(+)、重复拼接列表(*)

1. 列表拼接：+

squares = [1, 4, 9, 16, 25]
print(squares + [36, 49, 64, 81, 100])  # [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

2. 重复拼接列表：*

squares = [1, 4, 9, 16, 25]
print(squares*3) # [1, 4, 9, 16, 25, 1, 4, 9, 16, 25, 1, 4, 9, 16, 25]

四、计算列表长度：len()

squares = [1, 4, 9, 16, 25]
print(len(squares)) # 5

五、列表的的增删改查

5.1.增(增加)

s.append(x)
s.insert(i, x)
s.extend(t) 或 s += t

方法一：[start : end : step]：索引赋值

cubes = [1,8,27,64,125]
cubes[5:] = [1,2,3]
print(cubes) # [1, 8, 27, 64, 125, 1, 2, 3]

方法二：append()：追加末尾

cubes = [1,8,27,64,125]
cubes.append(216)
print(cubes) # [1, 8, 27, 64, 125, 216]

方法三：inserter()：指定位置插入

cubes = [1,8,27,64,125]
cubes.insert(1,124)
print(cubes)# [1, 124, 8, 27, 64, 125]

方法四：extend()：合并两个列表(在末尾添加)

cubes = [1,8,27,64,125]
cubes.extend([44,55,66])
print(cubes)# [1, 8, 27, 64, 125, 44, 55, 66]

也可以如下，批量添加元素到末尾，其实extend()方法内部也是这样处理数据的：

l1 = ['a','b','c','d']
for i in [1,2,3,4]:
    l1.append(i)
print(l1) # ['a', 'b', 'c', 'd', 1, 2, 3, 4]

方法五：合并两个列表(s += t)

cubes = [1,8,27,64,125]
print(cubes+[1]) # [1, 8, 27, 64, 125, 1]
print(cubes+[2,3]) # [1, 8, 27, 64, 125, 2, 3]

此方法，相当于方法四中for循环添加

5.2.删(删除)

循环删除列表时，容易入的坑(错误)。

del s[i:j] 和 del s[i:j:k]
 s.pop([i])
 s.remove(x)
 s.clear()

方法一：删除元素：[start : end] = []

letters = ['a','b','c','d','e','f','g']
letters[2:5] = []
print(letters) # ['a', 'b', 'f', 'g']

方法二：清空列表：[:]

letters = ['a','b','c','d','e','f','g']
letters[:] = []
print(letters) # []

方法三：删除末尾元素 pop()

letters = ['a','b','c','d','e','f','g']
letters.pop()
print(letters)

方法四：删除指定元素 pop(index)

letters = ['a','b','c','d','e','f','g']
letters.pop(0)
print(letters)

方法五：移除具体元素 remove()

letters = ['a','b','c','d','e','f','g']
letters.remove('g') # 元素不存在时，程序报错
print(letters)

此方法，当移除的元素不存在时，程序会报错。

方法六：清空列表 clear()

letters = ['a','b','c','d','e','f','g']
letters.clear()
print(letters) # []

方法七：删除某个或多个元素：del list[index : end : step]

letters = ['a','b','c','d','e','f','g']
# 删除单个元素
del letters[1]
print(letters) # ['a', 'c', 'd', 'e', 'f', 'g']
# 删除多个元素，切片(步长)删除该元素
del letters[0:2]
print(letters) # ['d', 'e', 'f', 'g']

方法八：删除整个列表：del list

letters = ['a','b','c','d','e','f','g']
del letters
# print(letters) # 删除整个列表了，这里不能打印列表出来

5.3.改(修改)

s[i] = x
s[i:j] = t
s[i:j:k] = t

方法一：修改单个元素(索引赋值)

letters = ['a','b','c','d','e','f','g']
# 索引赋值
letters[0] = 'A'
print(letters) # ['A', 'b', 'c', 'd', 'e', 'f', 'g']

方法二：修改区间内的元素(切片赋值)

letters = ['a','b','c','d','e','f','g']
letters[2:5] = ['C','D','E']
print(letters) # ['a', 'b', 'C', 'D', 'E', 'f', 'g']

注意：根据步长切片得到元素，一定要与待赋值元素个数一一对应：

letters = ['a','b','c','d','e','f','g']
letters[::2] = 'zzzz' # 等号右边的元素个数，必须与步长切片的元素个数相同
print(letters) # ['z', 'b', 'z', 'd', 'z', 'f', 'z']

5.4.查(查询)

index()：查找元素的下标

squares = [1,4,9,16,25]
index = squares.index(16)
print(index) # 3

count()：统计指定元素在列表出现的次数

letters = ['a','b','a','c','a','d','e']
num = letters.count('a')
print(num)

in，not in：查询是否存在于列表中

in : 在列表中，则返回Ture，否则是False
not in : 不在列表中，则返回True,否则是False

c = [1,2,3,4,5,6,7]
isIn = 3 in c
print(isIn) # True
isNotIn = 99 not in c
print(isNotIn) # True

for循环、for迭代

lists = ['A','B','C','D','E','F']
# 查询方法1：
print(lists[0]) # A
# 查询方法2：
for i in lists: # 可使用快捷键iter,快速创建"for i in lists:"
    print(i)

打印列表中所有元素的方法：方法一

letters = ['a','b','c','d']
for letter in letters: # 可使用快捷键iter,快速创建"for letter in letters:"
    print(letter)
"""输出
a
b
c
d
"""

打印列表中所有元素的方法：方法二

letters = ['a','b','c','d']
letter = iter(letters)
for i in range(0,len(letters)):
    print(next(letter))
"""输出
a
b
c
d
"""

六、复制列表

s *= n：将原字符串复制n次，组成新的字符串
赋值：没有创建新对象，两个变量指向同一个对象。
浅拷贝：拷贝第一层内容，创建了新对象。切片[:] 、copy()方法
深拷贝：拷贝所有和当前对象相关的内容。deepcopy()方法

1.序列复制n次：s *= n

l1 = ['str1','str2'] * 3
print(l1) # ['str1', 'str2', 'str1', 'str2', 'str1', 'str2']

2.切片赋值给新列表（浅层复制）——只复制第一层，其它层引用原来的

rawList = ['百度','360','阿里','腾讯']
'''复制rawList到copyList中'''
copyList = rawList[:] # 浅层拷贝，切片实际相当于新建列表，复制的列表与原列表关系不深
print(rawList) # ['百度', '360', '阿里', '腾讯']
print(copyList) # ['百度', '360', '阿里', '腾讯']
# 添加元素到原列表
rawList.append('网易')
'''查看原列表与副本的内存地址情况'''
print(id(rawList)) # 2462550735560（内存地址）
print(id(copyList)) # 2462550630024（内存地址）
'''查看原列表与副本内部元素变化情况：'''
print(rawList) # ['百度', '360', '阿里', '腾讯', '网易']
print(copyList) # ['百度', '360', '阿里', '腾讯']

注意：当原列表嵌套列表(可变类型)时，执行拷贝，拷贝得到的副本，添加元素到嵌套列表中，它们两个列表的变化情况如下：

rawList = ['百度','360','阿里','腾讯',['中国石油','国家电网']] # 列表嵌套列表
'''复制rawList到copyList中'''
copyList = rawList[:] # 浅层拷贝，内层列表不会复制，是指针引用，指向原列表的内层列表
print(rawList) # ['百度', '360', '阿里', '腾讯', ['中国石油', '国家电网']]
print(copyList) # ['百度', '360', '阿里', '腾讯', ['中国石油', '国家电网']]
# 添加元素到原列表
rawList[4].append('网易')
'''查看原列表与副本中嵌套列表的内存地址情况'''
print(id(rawList[4])) # 1793064345288
print(id(copyList[4])) # 1793064345288
'''查看原列表与副本的内存地址情况'''
print(id(rawList)) # 1871856170504（内存地址）
print(id(copyList)) # 1871855893192（内存地址）
'''查看原列表与副本内部元素变化情况：'''
print(rawList) # ['百度', '360', '阿里', '腾讯', ['中国石油', '国家电网', '网易']]
print(copyList) # ['百度', '360', '阿里', '腾讯', ['中国石油', '国家电网', '网易']]

综上所述，列表嵌套列表，当修改原嵌套列表里面的列表时，副本列表也会被修改。

3.浅层复制：list.copy()——只复制第一层，其它层引用原来的

列表嵌套列表，当浅层复制时，副本中内层列表的指针 指向 原列表中的内层列表(即副本的内层列表地址与原列表的内层列表地址不一致)

rawList = ['百度', '360', '阿里', '腾讯']
copyList = rawList.copy() # 浅层拷贝
print(rawList) # ['百度', '360', '阿里', '腾讯']
print(copyList) # ['百度', '360', '阿里', '腾讯']
# 添加元素到原列表
rawList.append('网易')
'''查看原列表与副本的内存地址情况'''
print(id(rawList)) # 2745554410440
print(id(copyList)) # 2745558710984
'''查看原列表与副本内部元素变化情况'''
print(rawList) # ['百度', '360', '阿里', '腾讯', '网易']
print(copyList) # ['百度', '360', '阿里', '腾讯']

综上所述：浅层复制中，删除原列表或者副本，都只能对自身产生影响，不会因删除原列表而导致副本改变，或者删除副本而导致原列表改变。

4.深层复制：直接赋值给新的列表、copy.deepcopy(x)

深层复制，不仅复制第一层内容，其它层的也复制。

• 直接赋值给新的列表，相当于指针指向原列表的内存地址。

rawList = ['百度','360','阿里','腾讯']
'''复制rawList到copyList中'''
copyList = rawList # 深层拷贝
print(rawList) # ['百度', '360', '阿里', '腾讯']
print(copyList) # ['百度', '360', '阿里', '腾讯']
# 添加元素到原列表
rawList.append('网易')
'''查看原列表与副本的变化情况：'''
print(id(rawList)) # 2297724451464（内存地址）
print(id(copyList)) # 2297724451464（内存地址）
'''查看原列表与副本内部元素变化情况：'''
print(rawList) # ['百度', '360', '阿里', '腾讯', '网易']
print(copyList) # ['百度', '360', '阿里', '腾讯', '网易']

• copy.deepcopy(x)：深层复制，列表中所有层的数据都复制(不仅仅第一层)。
  跟原列表有关系的都拷贝，内存地址是不一致

import copy
rawList = ['百度', '360', '阿里', '腾讯',['中国石油','国家电网']]
copyList = copy.deepcopy(rawList)
print(rawList) # ['百度', '360', '阿里', '腾讯', ['中国石油', '国家电网']]
print(copyList) # ['百度', '360', '阿里', '腾讯', ['中国石油', '国家电网']]
# 添加元素到原列表
rawList[4].append('中国邮政')
'''查看原列表与副本的内存地址情况'''
print(id(rawList)) # 2501738604488
print(id(copyList)) # 2501738591688
print(id(rawList[4])) # 2501738604680
print(id(copyList[4])) # 2501738604552
'''查看原列表与副本内部元素变化情况：'''
print(rawList) # ['百度', '360', '阿里', '腾讯', ['中国石油', '国家电网', '中国邮政']]
print(copyList) # ['百度', '360', '阿里', '腾讯', ['中国石油', '国家电网']]

• 浅层复制与深层复制

浅层与深层复制的区别仅与复合对象（即包含列表或类的实例等其他对象的对象）相关：

浅层复制 构造一个新的复合对象，然后（在尽可能的范围内）将原始对象中找到的对象的 引用 插入其中。
深层复制 构造一个新的复合对象，然后，递归地将在原始对象里找到的对象的 副本 插入其中。

深度复制操作通常存在两个问题, 而浅层复制操作并不存在这些问题：

递归对象 (直接或间接包含对自身引用的复合对象) 可能会导致递归循环。
由于深层复制会复制所有内容，因此可能会过多复制（例如本应该在副本之间共享的数据）。

七、队列与堆栈

1.队列：

• 队列：先进先出。即先进去的元素先出来。

# 1.定义一个空列表
l = []
# 2.入队：追加元素append()
l.append(111) # l = [111,]
l.append(222) # l = [111,222,]
l.append(333) # l = [111,222,333]
print(l)
# 3.出队：弹出第一个pop(0)
print(l.pop(0)) # 111   l = [222,333]
print(l.pop(0)) # 222   l = [333,]
print(l.pop(0)) # 333   l = []

• 列表中有数据的队列操作，方法1：

l1 = ["Eric", "John", "Michael"]
# 入队
l1.append('Terry')
l1.append('Graham')
print('入队后，队列的情况:',l1) # 入队后，队列的情况: ['Eric', 'John', 'Michael', 'Terry', 'Graham']
# 出队
print(l1.pop(0),l1) # Eric ['John', 'Michael', 'Terry', 'Graham']
print(l1.pop(0),l1) # John ['Michael', 'Terry', 'Graham']
print(l1.pop(0),l1) # Michael ['Terry', 'Graham']

• 列表中有数据的队列操作，方法2(collections集合模块下的deque队列)：

from collections import deque
queue = deque(["Eric", "John", "Michael"])
# 入队：
queue.append('Terry')
queue.append('Graham')
print('入队后，队列的情况:',queue) # 入队后，队列的情况: deque(['Eric', 'John', 'Michael', 'Terry', 'Graham'])
# 出队:popleft()
print(queue.popleft(),queue) # Eric deque(['John', 'Michael', 'Terry', 'Graham'])
print(queue.popleft(),queue) # John deque(['Michael', 'Terry', 'Graham'])

2.堆栈

• 堆栈：后进前出。即最后进去的元素先出来。

# 1.定义一个空列表
l1 = []
# 2.入栈：追加元素append()
l1.append(111)
l1.append(222)
l1.append(333)
l1.append(444)
print(l1) # [111, 222, 333, 444]
# 3.出栈：弹出最后一个pop()
print(l1.pop()) # 444
print(l1.pop()) # 333
print(l1.pop()) # 222
print(l1.pop()) # 111

八、压缩两个列表(了解)

zip([iterable, …])：返回元组列表

list1 = ["what", "I'm", "sorting", "by"]
list2 = ["something", "else", "to", "sort"]
pairs = zip(list1, list2)
for item in pairs:
    print(item,end='\t')

输出结果：

('what', 'something')	("I'm", 'else')	('sorting', 'to')	('by', 'sort')

九、列表的推导式

1.前言：创建一个平方列表
不使用列表推导式，写法如下：

squares = []
for x in range(10):
    squares.append(x ** 2)
print(squares)  # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

2.列表推导式
求0-9的平方根：

squares = [x ** 2 for x in range(10)]
print(squares)  # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

复杂的列表推导式：
快速创建嵌套列表

print([(x, x ** 2) for x in range(6)])  # [(0, 0), (1, 1), (2, 4), (3, 9), (4, 16), (5, 25)]

squares = [(x, y) for x in [1, 2, 3] for y in [3, 1, 4] if x != y]
print(squares)  # [(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]

也可以这样写：

combs = []
for x in [1, 2, 3]:
    for y in [3, 1, 4]:
        if x != y:
            combs.append((x, y))
print(combs)  # [(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]

求平方、绝对值，去除所有负数？

vec = [-4, -2, 0, 2, 4]
print([x * 2 for x in vec])  # [-8, -4, 0, 4, 8]，求平方
print([x for x in vec if x >= 0])  # [0, 2, 4]，去除所有负数
print([abs(x) for x in vec])  # [4, 2, 0, 2, 4] 求绝对值

去除列表中，字符串的空白：

freshfruit = ['  banana', '  loganberry ', 'passion fruit  ']
l1 = [item.strip() for item in freshfruit]
print(l1)  # ['banana', 'loganberry', 'passion fruit']

列表推导式可以使用复杂的表达式和嵌套函数：

from math import pi
print([str(round(pi, i)) for i in range(1, 6)]) # ['3.1', '3.14', '3.142', '3.1416', '3.14159']

十、嵌套列表、多维列表

1.嵌套列表和多维列表

a = ['a','b','c']
n = (1,2,3)
x = [a,n]
print(x) # [['a', 'b', 'c'], (1, 2, 3)]

嵌套列表的取值：

x = [['a', 'b', 'c'], [1, 2, 3]]
print(x[0]) # ['a', 'b', 'c']
print(x[1][1]) # 2

2.多维列表

2.1 例题（面试题）

lists = [[]] * 3
lists[0].append(3)
lists[1].append(4)
lists[2].append(5)
print(lists) # [[3, 4, 5], [3, 4, 5], [3, 4, 5]]

当修改任意一个元素，其它也会被修改：
原因：在于 [[]] 是一个包含了一个空列表的单元素列表，所以 [[]] * 3 结果中的三个元素都是对这一个空列表的引用。修改 lists 中的任何一个元素实际上都是对这一个空列表的修改。

lists = [[]] * 3
lists[0].append(3)
lists[1].append(4)
lists[2].append(5)
print(lists) # [[3, 4, 5], [3, 4, 5], [3, 4, 5]]
lists[1][1] = 10
print(lists) # [[3, 10, 5], [3, 10, 5], [3, 10, 5]] 嵌套列表中的列表第2个元素，都修改为10了

实现修改其中一个元素，其它元素不修改的方法：

• 2.1.1 初步实现

lists = [[] for i in range(3)]
print(lists) # [[], [], [], []]
lists[0].append(3)
lists[1].append(5)
lists[2].append(7)
print(lists) # [[3], [5], [7]]

• 2.1.2 进一步实现

lists = [[None]*2]*3
print(lists) # [[None, None], [None, None], [None, None]]
# 对多维列表赋值
lists[0][0] = 5
# 从结果看出，多维列表，多处都更新值，达不到预料结果
print(lists) # [[5, None], [5, None], [5, None]]

• 2.1.3 最终实现：方法一

A = [None]*3
for i in range(3):
    A[i] = [None]*2
print(A)
A[1][1] = 7 # 检测赋值后，其它会修改否
print(A) # [[None, None], [None, 7], [None, None]]

• 2.1.3 最终实现：方法二

w,h = 2,3
B = [[None]*w for i in range(h)]
print(B)# [[None, None], [None, None], [None, None]]
B[1][1] = 7 # 检测赋值后，其它会修改否
print(B) # [[None, None], [None, 7], [None, None]]

2.2 例题：下面这个3x4的矩阵，它由3个长度为4的列表组成：

matrix = [
    [1, 2, 3, 4],
    [5, 6, 7, 8],
    [9, 10, 11, 12],
]

• 取矩阵中第一列的数据：

print([row[0] for row in matrix]) # [1, 5, 9]

• 求矩阵的逆矩阵，方法一：

sq = [[row[i] for row in matrix] for i in range(4)]
print(sq) # [[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

• 求矩阵的逆矩阵，方法二：

transposed = []
for i in range(4):
    transposed.append([row[i] for row in matrix])
print(transposed) # [[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

• 求矩阵的逆矩阵，方法三：

transposed = []
for i in range(4):
    transposed_row = []
    for row in matrix:
        transposed_row.append(row[i])
    transposed.append(transposed_row)
print(transposed) # [[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

• 求矩阵的逆矩阵，方法四：内置函数，压缩两个列表

l1 = list(zip(*matrix))
print(l1) # [(1, 5, 9), (2, 6, 10), (3, 7, 11), (4, 8, 12)]

3.多维列表转换为一维列表

3.1 列表嵌套列表

vec = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
"""
    for elem in vec:
        for num in elem:
            pass
"""
print([num for elem in vec for num in elem])  # [1, 2, 3, 4, 5, 6, 7, 8, 9]

3.2 列表嵌套元组

lists = [("I'm", 'else'), ('by', 'sort'), ('sorting', 'to'), ('what', 'something')]
print([item for li in lists for item in li]) # ["I'm", 'else', 'by', 'sort', 'sorting', 'to', 'what', 'something']

3.3 列表嵌套元组，只取元组第2个值

lists = [("I'm", 'else'), ('by', 'sort'), ('sorting', 'to'), ('what', 'something')]
# 遍历，取元组第2个元素，组成一个列表
result = [x[1] for x in lists]
print(result) # ['else', 'sort', 'to', 'something']

十一、排序

list.sort(key=None, reverse=False)
list.reverse()

1.升序排列：sort()

对列表中的内容，根据函数中默认的key键进行升序排列

letters = ['g', 'c', 'a', 'f', 'd', 'b', 'e']
letters.sort()
print(letters) # ['a', 'b', 'c', 'd', 'e', 'f', 'g']

2.降序排列：sort(reverse=True)

对列表中的内容，根据函数中默认的key键进行降序排列

letters = ['g', 'c', 'a', 'f', 'd', 'b', 'e']
letters.sort(reverse=True)
print(letters) # ['g', 'f', 'e', 'd', 'c', 'b', 'a']

3.翻(反)转列表：reverse()

letters = ['g', 'c', 'a', 'f', 'd', 'b', 'e']
letters.reverse() # 注意：该函数没有根据字母表的顺序排序
print(letters)  # ['e', 'b', 'd', 'f', 'a', 'c', 'g']