1. 列表是什么？ #

• 列表（list）是有序、可变的序列，用方括号 [] 表示，元素可以是任意类型，甚至同一列表里混放数字、字符串、布尔值。
• 与元组不同，列表创建后可以增删改元素。
• 与字典不同，列表靠下标（0、1、2…）访问，不靠键名。
• 全栈开发里列表无处不在：接口返回的 JSON 数组、分页里的 results、多选框勾选项、一批待处理的订单 ID 等。
• 习惯用 for item in lst 逐项处理，或配合列表推导式快速生成新列表。

users = ["alice", "bob"]
print(users)
mixed = [1, "ok", True]
print(mixed)
empty = []
print(empty)

2. 创建与访问 #

• 列表用字面量 [] 或 list() 创建。
• 通过索引访问元素：非负索引从前往后（0 是第一个），负索引从后往前（-1 是最后一个）。
• 切片 lst[start:end] 取子序列，包含 start、不包含 end，得到的是新列表，不修改原列表。
• 赋值 fruits[1] = "blueberry" 会原地修改该位置的元素，这是列表「可变」最直接的体现。
• 越界访问（如 fruits[99]）会抛出 IndexError。

fruits = ["apple", "banana", "orange"]

print(fruits[0])      # apple
print(fruits[-1])     # orange（最后一个）
print(fruits[1:3])    # ['banana', 'orange']（切片，不含索引 3）

fruits[1] = "blueberry"   # 修改元素

3. 增删元素 #

• 列表提供一组原地修改的方法：在末尾追加、指定位置插入、按值删除、弹出元素等。
• 注意 append 与 extend 的区别：append(x) 把整个 x 当作一个元素加进去。
• extend(iterable) 把可迭代对象里的元素逐个并入。
• 误用 append([6, 7]) 会得到嵌套列表 [..., [6, 7]]，而 extend([6, 7]) 才是扁平合并。
• remove(x) 只删第一个匹配值，不存在会报 ValueError。
• pop() 删除并返回被删元素，常用于栈式取用；需要一次性清空用 clear()。

items = [1, 2]
items.append(3)           # [1, 2, 3]
print(items)
items.extend([4, 5])      # [1, 2, 3, 4, 5]
print(items)
items.append([6, 7])      # [..., [6, 7]]  整个子列表作为一个元素
print(items)
items = [1, 2]
items.extend([6, 7])      # [1, 2, 6, 7]   逐个并入
print(items)
items.remove(2)
print(items)
last = items.pop()        # 弹出最后一个
print(last)
print(items)

4. 常用操作 #

• 除增删改外，列表还支持长度、成员检测、排序与字符串拼接等常见操作。
• len(lst) 得元素个数；x in lst 判断是否存在（比反复 index 查找更直观）。
• 多个字符串列表用 ", ".join(tags) 拼成一行，分隔符可自定。
• lst.sort() 原地排序，原列表顺序被改掉。
• sorted(lst) 返回新列表，原列表不变。
• 展示、导出时若还要保留原顺序，用 sorted()；确定要就地整理数据再用 .sort()。

tags = ["python", "web"]

print(len(tags))              # 2
print("web" in tags)          # True
print(", ".join(tags))        # python, web（字符串拼接）

nums = [3, 1, 4, 1, 5]
nums.sort()                   # 原地排序：[1, 1, 3, 4, 5]
print(nums)
sorted_nums = sorted(nums)    # 返回新列表，不改变原列表（需要保留原序时用）
print(sorted_nums)

5. 遍历 #

• 遍历列表最常用 for item in lst：依次取出每个元素，不关心下标时首选这种写法。
• 需要同时拿到索引和值时（如生成序号、写日志「第几条失败」），用 enumerate(lst)。
• 默认索引从 0 开始，也可传 start=1 从 1 计数。
• 不要用 for i in range(len(lst)) 再 lst[i] 访问，除非确实要根据索引做特殊逻辑。
• 多数场景 enumerate 更清晰。

orders = ["A001", "A002", "A003"]

for order_id in orders:
    print(order_id)

for i, order_id in enumerate(orders):
    print(i, order_id)        # 需要索引时用 enumerate

6. 列表推导式 #

• 列表推导式用一行从已有序列生成新列表，结构为 [表达式 for 变量 in 可迭代对象 if 条件]，条件部分可省略。
• 适合「对每个元素做同一变换」或「筛出满足条件的子集」，比手写 for + append 更简洁。
• 项目里处理接口字段、批量格式化时很常见。
• 推导式里不宜塞入多行复杂逻辑；若含多层 if、副作用或难读的嵌套，改回普通 for 循环，可读性优先。

nums = [1, 2, 3, 4, 5]
squares = [x ** 2 for x in nums]
evens = [x for x in nums if x % 2 == 0]

names = ["Alice", "Bob"]
lower_names = [n.lower() for n in names]

7. 复制与嵌套 #

• 赋值 b = a 不会让两个变量各持一份列表，而是共享同一对象——改 b 也会影响 a。
• 需要独立副本时用 a.copy()、a[:] 或 list(a)，都属于浅拷贝。
• 浅拷贝下最外层列表是新对象，若元素本身是可变对象（如内层列表、字典），内外层仍可能联动。
• 嵌套列表（如 [[1, 2], [3, 4]]）浅拷贝后，修改内层子列表仍会影响原结构。
• 要完全独立的深层副本，使用 copy.deepcopy(a)（需 import copy）。

a = [1, 2, 3]
b = a.copy()          # 或 b = a[:]，浅拷贝
b.append(4)           # a 不变

nested = [[1, 2], [3, 4]]
shallow = nested.copy()
shallow[0].append(99)   # nested 的内层也被改了

import copy
deep = copy.deepcopy(nested)  # 完全独立副本

8. 项目开发要点 #

• 日常写业务时，把列表当「一批同类数据」处理即可。
• 接口数据：response.json() 常常是 list[dict]，用 for item in data 处理。
• append vs extend：合并列表用 extend；追加单个对象用 append。
• 排序：展示用 sorted() 保留原列表；确定要改原列表用 .sort()。
• 不要用列表当下标字典：需要按 id 查找时用 dict，不要 list.index 反复查。
• 共享引用：赋值 b = a 共享同一列表；要副本用 .copy() 或 list(a)。
• 空列表判断：if not items: 即可。