Python 列表进阶：那些你该掌握的核心操作
今天来复习下 Python 里最常用的数据结构之一 ——列表（List）的基础操作和拓展，温故才能知新～
一、列表的 3 种组合方式
1. “+”运算符：拼接两个列表
像拼字符串一样拼列表，会生成新列表，原列表不变。
优点：直观易懂
缺点：拼接大量数据时效率低（每次都新建列表）
list_b = [3, 4]
new_list = list_a + list_b
print(new_list) # 输出 [1, 2, 3, 4]
print(list_a) # 原列表不变：[1, 2]
*2. 运算符：重复列表元素
把列表里的元素重复指定次数，同样生成新列表，原列表不变。
适用场景：快速创建重复元素的列表
repeated_list = original_list * 3
print(repeated_list) # 输出 [1, 2, 1, 2, 1, 2]
print(original_list) # 原列表不变：[1, 2]
3. extend()方法：原地扩展列表
把另一个序列（列表、元组等）的元素直接添加到原列表末尾，修改原列表，无返回值。
优点：效率比+更高（不用新建列表）
list_b = [3, 4]
list_a.extend(list_b)
print(list_a) # 原列表被修改：[1, 2, 3, 4]
二，元素查询：成员检查in/not in
想知道某个元素在不在列表里？用in（存在）或not in（不存在），返回布尔值True/False：
print("banana" in fruits) # 检查存在：True
print("orange" not in fruits)# 检查不存在：True
三、元素删除：3 种常用方式
1. del语句：按索引 / 切片删除
del是 Python 的语句（不是方法），可以按索引或切片删除一个 / 多个元素，直接修改原列表，无返回值。
适用场景：明确知道要删除元素的索引 / 范围
del numbers[0] # 删除索引0的元素
print(numbers) # 输出 [20, 30, 40, 50]del numbers[1:3] # 删除索引1-2的切片
print(numbers) # 输出 [20, 50]
2. pop()方法：删除并返回元素
pop()是方法，删除指定索引的元素并返回它；省略索引时，默认删除并返回最后一个元素。
适用场景：需要 “取出” 元素并后续使用
removed_item = numbers.pop(1) # 删除索引1的元素并返回
print(removed_item) # 输出 20
print(numbers) # 输出 [10, 30, 40]last_item = numbers.pop() # 默认删除最后一个元素
print(last_item) # 输出 40
print(numbers) # 输出 [10, 30]
3. remove()方法：按值删除
remove()是方法，按 “值” 删除列表中第一个匹配到的元素，直接修改原列表，无返回值。
注意：若要删除的值不存在，会抛出ValueError
numbers.remove(20) # 删除第一个20
print(numbers) # 输出 [10, 30, 20, 40]
4. clear()方法：清空整个列表
clear()是方法，用于移除列表中所有元素，将列表变为空列表，是 “就地” 操作，无返回值。
效果等同于 del list[:]
适用场景：需要快速清空列表，保留列表对象本身
print(f"Original: {numbers}") # 输出 Original: [10, 20, 30]
numbers.clear()
print(f"After clear: {numbers}") # 输出 After clear: []
print(f"Length now: {len(numbers)}") # 输出 Length now: 0
四、列表整理：反转与排序
1. reverse()：就地反转列表
reverse()是方法，会直接修改原列表，将元素顺序反转，无返回值。
和反向切片[::-1]的区别：切片会生成新列表，reverse()是原地修改
print(f"Original: {nums}") # 输出 Original: [1, 2, 3, 4]
nums.reverse()
print(f"After reverse: {nums}") # 输出 After reverse: [4, 3, 2, 1]
2. sort()：就地排序列表
sort()是方法，默认对列表进行升序排序，直接修改原列表，无返回值。
后续可学习降序、自定义排序规则等进阶用法
print(f"Original: {nums}") # 输出 Original: [3, 1, 4, 1, 5, 9, 2]
nums.sort()
print(f"After sort: {nums}") # 输出 After sort: [1, 1, 2, 3, 4, 5, 9]
3. sorted()：生成排序后的新列表
sorted()是内置函数，对可迭代对象（如列表）排序后，返回新的排序列表，原列表保持不变。
适用场景：不想修改原列表时更安全
print(f"Original nums: {nums}") # 输出 Original nums: [3, 1, 4, 1, 5, 9, 2]
new_list = sorted(nums)
print(f"New sorted list: {new_list}") # 输出 New sorted list: [1, 1, 2, 3, 4, 5, 9]
print(f"Original nums is unchanged: {nums}") # 原列表不变
五、列表复制：避开 “引用赋值” 的陷阱
1. 错误方式：直接赋值（引用赋值）
用=直接赋值，不会创建新列表，只是让两个变量指向同一个列表对象。修改其中一个，另一个也会跟着变：
b = a # 只是引用同一列表
b.append(4)
print(f"List a: {a}") # 输出 List a: [1, 2, 3, 4]（a也被修改了）
print(f"List b: {b}") # 输出 List b: [1, 2, 3, 4]
2. 正确方式：创建浅拷贝
要得到 “内容相同但独立” 的新列表，需显式创建副本（浅拷贝），常用两种方法：
方法一：copy()方法
方法二：完整切片[:]
这两种方式都会生成新列表，修改副本不会影响原列表：
b = a.copy() # 方法一：copy()
c = a[:] # 方法二：完整切片
b.append(4)
c.append(5)
print(f"List a: {a}") # 原列表不变：[1, 2, 3]
print(f"List b: {b}") # 副本b：[1, 2, 3, 4]
print(f"List c: {c}") # 副本c：[1, 2, 3, 5]
注意：浅拷贝的局限性
如果列表中包含嵌套列表（比如a = [[1,2], 3]），浅拷贝只会复制外层列表的引用，嵌套部分仍会共享。这种情况需要用 “深拷贝”，后续跟进学习～