Python列表：你的万能瑞士军刀，从入门到“切片”高手 🍕

掌握了Python列表，你就掌握了数据处理的一半江山——这话一点都不夸张！

1. 列表定义与切片：Python中的“瑞士军刀”

列表是什么？

想象一下你去购物，手里拿着一张购物清单——这就是列表！在Python中，列表是一个有序、可变、允许重复元素的集合。

# 定义列表的几种方式
shopping_list = ["苹果", "香蕉", "牛奶", "鸡蛋"]  # 最常用的方式
numbers = [1, 2, 3, 4, 5]
mixed_list = [42, "你好", 3.14, True, [1, 2, 3]]  # Python列表可以混合不同类型！
empty_list = []  # 空列表
another_empty = list()  # 使用list()构造函数

print(f"购物清单: {shopping_list}")
print(f"混合列表: {mixed_list}")

切片：列表的“精准切割术” 🔪

切片就像切蛋糕——你可以只取你想要的那一块！

# 创建一个测试列表
fruits = ["苹果", "香蕉", "橙子", "葡萄", "芒果", "草莓", "西瓜"]

# 基本切片：list[start:end:step]
print(fruits[1:4])      # ['香蕉', '橙子', '葡萄'] - 索引1到3（不包含4）
print(fruits[:3])       # ['苹果', '香蕉', '橙子'] - 从开始到索引2
print(fruits[3:])       # ['葡萄', '芒果', '草莓', '西瓜'] - 从索引3到最后
print(fruits[-3:])      # ['草莓', '西瓜'] - 最后两个元素
print(fruits[::2])      # ['苹果', '橙子', '芒果', '西瓜'] - 每隔一个取一个
print(fruits[::-1])     # ['西瓜', '草莓', '芒果', '葡萄', '橙子', '香蕉', '苹果'] - 反转列表

# 切片不会修改原列表，而是返回一个新列表
original = [1, 2, 3, 4, 5]
sliced = original[1:4]
sliced[0] = 999
print(f"原列表: {original}")  # [1, 2, 3, 4, 5] - 没变！
print(f"切片: {sliced}")      # [999, 3, 4] - 变了

2. 列表方法大全：增删改查样样精通

增：给列表”添砖加瓦” 🧱

foods = ["披萨", "汉堡"]

# append() - 在末尾添加一个元素
foods.append("薯条")
print(f"添加薯条后: {foods}")  # ['披萨', '汉堡', '薯条']

# extend() - 扩展列表（添加多个元素）
foods.extend(["可乐", "冰淇淋"])
print(f"扩展后: {foods}")  # ['披萨', '汉堡', '薯条', '可乐', '冰淇淋']

# insert() - 在指定位置插入元素
foods.insert(1, "炸鸡")  # 在索引1的位置插入
print(f"插入炸鸡后: {foods}")  # ['披萨', '炸鸡', '汉堡', '薯条', '可乐', '冰淇淋']

删：做列表的”断舍离” 🗑️

# remove() - 删除第一个匹配的元素
foods.remove("汉堡")
print(f"删除汉堡后: {foods}")  # ['披萨', '炸鸡', '薯条', '可乐', '冰淇淋']

# pop() - 删除并返回指定位置的元素
popped_item = foods.pop(2)  # 删除索引2的元素
print(f"弹出索引2: {popped_item}")  # 薯条
print(f"弹出后列表: {foods}")  # ['披萨', '炸鸡', '可乐', '冰淇淋']

# clear() - 清空列表
temp_list = [1, 2, 3]
temp_list.clear()
print(f"清空后: {temp_list}")  # []

改：列表”整容术” ✨

# 直接通过索引修改
foods[1] = "炸鸡腿"
print(f"修改后: {foods}")  # ['披萨', '炸鸡腿', '可乐', '冰淇淋']

# 批量修改可以使用切片
numbers = [0, 1, 2, 3, 4, 5]
numbers[1:4] = [10, 20, 30]
print(f"批量修改: {numbers}")  # [0, 10, 20, 30, 4, 5]

查：列表”侦探工作” 🔍

# index() - 查找元素第一次出现的索引
colors = ["红", "绿", "蓝", "绿", "黄"]
green_index = colors.index("绿")
print(f"'绿'第一次出现在索引: {green_index}")  # 1

# count() - 统计元素出现的次数
green_count = colors.count("绿")
print(f"'绿'出现了 {green_count} 次")  # 2

# in 运算符 - 检查元素是否存在
has_blue = "蓝" in colors
print(f"列表中有蓝色吗? {has_blue}")  # True

排序与翻转：列表”整理术” 📊

# sort() - 原地排序（修改原列表）
numbers = [3, 1, 4, 1, 5, 9, 2, 6]
numbers.sort()
print(f"升序排序: {numbers}")  # [1, 1, 2, 3, 4, 5, 6, 9]

numbers.sort(reverse=True)
print(f"降序排序: {numbers}")  # [9, 6, 5, 4, 3, 2, 1, 1]

# sorted() - 返回新排序列表，不修改原列表
original = [3, 1, 2]
sorted_list = sorted(original)
print(f"原列表: {original}")      # [3, 1, 2]
print(f"排序后新列表: {sorted_list}")  # [1, 2, 3]

# reverse() - 原地反转列表
colors = ["红", "橙", "黄", "绿", "蓝"]
colors.reverse()
print(f"反转后: {colors}")  # ['蓝', '绿', '黄', '橙', '红']

3. 列表拷贝：浅拷贝 vs 深拷贝的”分身术”

浅拷贝：只拷贝”皮肤”，不拷贝”内脏”

# 方法1：copy()方法
original = [1, 2, 3]
shallow_copy = original.copy()
shallow_copy[0] = 999
print(f"原列表: {original}")        # [1, 2, 3]
print(f"浅拷贝: {shallow_copy}")    # [999, 2, 3]

# 方法2：切片法
shallow_copy2 = original[:]
shallow_copy2[1] = 888
print(f"切片拷贝: {shallow_copy2}")  # [1, 888, 3]

# 浅拷贝的问题：嵌套列表只拷贝引用
original = [[1, 2], [3, 4]]
shallow_copy = original.copy()

shallow_copy[0][0] = 999  # 修改嵌套列表中的元素
print(f"原列表: {original}")      # [[999, 2], [3, 4]] - 也被修改了！
print(f"浅拷贝: {shallow_copy}")  # [[999, 2], [3, 4]]

深拷贝：连”内脏”也一起拷贝

import copy

original = [[1, 2], [3, 4]]
deep_copy = copy.deepcopy(original)

deep_copy[0][0] = 999  # 修改深拷贝中的元素
print(f"原列表: {original}")    # [[1, 2], [3, 4]] - 没被修改！
print(f"深拷贝: {deep_copy}")   # [[999, 2], [3, 4]]

比喻理解：

浅拷贝：就像复印一张纸，纸上的文字被复制了，但如果纸上有”请查看抽屉”的指示，那么原纸和复印件都会指向同一个抽屉。
深拷贝：不仅复印了纸，还把抽屉里的东西也全部复印了一份，两者完全独立。

4. 列表运算与嵌套：列表的”社交活动” 👥

列表加法和乘法

# 加法：连接两个列表
list1 = [1, 2, 3]
list2 = [4, 5, 6]
result = list1 + list2
print(f"列表加法: {result}")  # [1, 2, 3, 4, 5, 6]

# 乘法：重复列表
repeat_list = ["嗨"] * 3
print(f"列表乘法: {repeat_list}")  # ['嗨', '嗨', '嗨']

# 小心！乘法创建嵌套列表时的陷阱
matrix_wrong = [[0] * 3] * 3  # 这种方式有问题！
matrix_wrong[0][0] = 1
print(f"错误的方式: {matrix_wrong}")  # [[1, 0, 0], [1, 0, 0], [1, 0, 0]] - 全改了！

# 正确的方式
matrix_correct = [[0] * 3 for _ in range(3)]
matrix_correct[0][0] = 1
print(f"正确的方式: {matrix_correct}")  # [[1, 0, 0], [0, 0, 0], [0, 0, 0]]

嵌套列表：列表中的列表

# 创建二维列表（矩阵）
matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

# 访问嵌套列表元素
print(f"第一行: {matrix[0]}")          # [1, 2, 3]
print(f"第二行第三列: {matrix[1][2]}")  # 6

# 遍历嵌套列表
print("矩阵内容:")
for row in matrix:
    for item in row:
        print(item, end=" ")
    print()
# 输出:
# 1 2 3
# 4 5 6
# 7 8 9

5. 列表推导式：Python的”语法糖” 🍬

列表推导式是Python最优雅的特性之一，让代码更简洁、更Pythonic！

基本推导式

# 传统方式：创建平方数列表
squares_old = []
for i in range(1, 6):
    squares_old.append(i ** 2)
print(f"传统方式: {squares_old}")  # [1, 4, 9, 16, 25]

# 列表推导式：一行搞定！
squares_new = [i ** 2 for i in range(1, 6)]
print(f"推导式: {squares_new}")  # [1, 4, 9, 16, 25]

带条件的推导式

# 只包含偶数的平方
even_squares = [i ** 2 for i in range(1, 11) if i % 2 == 0]
print(f"偶数平方: {even_squares}")  # [4, 16, 36, 64, 100]

# 将列表中的负数转为正数
numbers = [-5, 3, -2, 9, -1]
abs_values = [abs(x) for x in numbers]
print(f"绝对值: {abs_values}")  # [5, 3, 2, 9, 1]

嵌套推导式

# 创建乘法表
multiplication_table = [[i * j for j in range(1, 4)] for i in range(1, 4)]
print("乘法表:")
for row in multiplication_table:
    print(row)
# 输出:
# [1, 2, 3]
# [2, 4, 6]
# [3, 6, 9]

# 扁平化嵌套列表
nested_list = [[1, 2, 3], [4, 5], [6, 7, 8, 9]]
flat_list = [item for sublist in nested_list for item in sublist]
print(f"扁平化: {flat_list}")  # [1, 2, 3, 4, 5, 6, 7, 8, 9]

推导式 vs 传统循环

场景	传统循环	列表推导式
简单转换	代码多，易读	简洁，Pythonic
复杂逻辑	更清晰	可能难以理解
性能	稍慢	稍快（优化过的C代码）
副作用	容易处理	不适合有副作用的操作

黄金法则：如果推导式让代码更清晰易懂，就用它；如果变得难以理解，就回到传统循环。

总结：列表的”生存指南” 📚

Python列表就像你的数字瑞士军刀：

创建简单：用方括号[]就能定义
操作丰富：增删改查排序样样行
切片灵活：像切蛋糕一样取数据
拷贝小心：浅拷贝 vs 深拷贝要分清
推导式优雅：一行代码顶多行

记住，列表是有序、可变的，这是它与元组（不可变）和集合（无序）的主要区别。

# 最后来个综合小例子
# 食堂菜单管理系统
menu = ["鱼香肉丝", "宫保鸡丁", "麻婆豆腐"]

# 添加新菜
menu.append("回锅肉")
menu.insert(1, "水煮鱼")

# 删除不受欢迎的菜
if "麻婆豆腐" in menu:
    menu.remove("麻婆豆腐")

# 今日特价：把第一个菜放到最后
special = menu.pop(0)
menu.append(f"{special}(特价)")

# 使用推导式生成带编号的菜单
numbered_menu = [f"{i+1}. {dish}" for i, dish in enumerate(menu)]
print("今日菜单:")
for item in numbered_menu:
    print(item)

# 输出:
# 今日菜单:
# 1. 水煮鱼
# 2. 宫保鸡丁
# 3. 回锅肉
# 4. 鱼香肉丝(特价)