在 Python 中，翻转（反转）列表是一个基础但重要的操作。以下是几种常用的方法及其详细说明：

1. 使用切片操作（最简洁）

my_list = [1, 2, 3, 4, 5]
reversed_list = my_list[::-1]  # 步长为 -1 表示反向
print(reversed_list)  # 输出 [5, 4, 3, 2, 1]

特点：

• 创建新列表，原列表不变
• 适用于所有可切片对象（字符串、元组等）

2. 使用reverse()方法（原地修改）

my_list = ['a', 'b', 'c']
my_list.reverse()  # 直接修改原列表
print(my_list)  # 输出 ['c', 'b', 'a']

注意：

• 直接修改原列表，不返回新列表
• 返回值为 None（不要写成 new_list = my_list.reverse()）

3. 使用reversed()函数（返回迭代器）

original = [10, 20, 30]
reversed_list = list(reversed(original))  # 需转换为 list
print(reversed_list)  # 输出 [30, 20, 10]

特点：

• 返回的是反向迭代器（需用 list() 转换）
• 不修改原列表
• 适合处理大列表（惰性计算）

4. 使用循环（理解原理）

方法 1：从后向前遍历

original = [1.1, 2.2, 3.3]
reversed_list = []
for i in range(len(original)-1, -1, -1):  # 从最后索引到 0
    reversed_list.append(original[i])
print(reversed_list)  # 输出 [3.3, 2.2, 1.1]

方法 2：头部插入法

original = ['x', 'y', 'z']
reversed_list = []
for item in original:
    reversed_list.insert(0, item)  # 每次插入到首位
print(reversed_list)  # 输出 ['z', 'y', 'x']

注意：insert(0) 效率较低（时间复杂度 O(n^2)），仅适合学习。

5. 性能对比

*reversed() 返回迭代器，实际遍历为 O(n)

6. 特殊场景处理

案例 1：反转嵌套列表

nested = [[1, 2], [3, 4], [5, 6]]
# 仅反转外层
print(nested[::-1])  # 输出 [[5, 6], [3, 4], [1, 2]]
# 反转所有层级
fully_reversed = [sublist[::-1] for sublist in nested[::-1]]
print(fully_reversed)  # 输出 [[6, 5], [4, 3], [2, 1]]

案例 2：处理其他序列

# 字符串
text = "hello"
print(text[::-1])  # 输出 "olleh"

# 元组
my_tuple = (1, 2, 3)
print(tuple(reversed(my_tuple)))  # 输出 (3, 2, 1)

7. 常见问题解答

Q1：为什么reverse()返回None？

Python 的设计约定：原地操作方法通常返回 None（如 sort()），明确区分是否创建新对象。

Q2：如何判断列表是否回文？

def is_palindrome(lst):
    return lst == lst[::-1]

print(is_palindrome([1, 2, 1]))  # True

Q3：哪种方法最快？

• 小列表：切片和 reverse() 性能接近
• 大列表：reverse() 最优（原地操作）

8. 综合练习

1. 编写函数，保留原列表并返回反转副本：
   
   

def reverse_copy(lst):
    return lst[::-1]

2. 实现递归版列表反转：

def recursive_reverse(lst):
    return recursive_reverse(lst[1:]) + [lst[0]] if lst else []

3. 对比不同方法的执行时间（使用 timeit 模块）

掌握列表反转是算法基础，后续可延伸学习：

• 链表反转
• 栈（后进先出）的应用
• 递归与迭代的转换