# 空列表
empty = []

# 同类型元素
numbers = [1, 2, 3, 4, 5]

# 不同类型元素（Python 允许）
mixed = [1, "hello", 3.14, True, None]

# 嵌套列表（矩阵/多维数据）
matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9],
]

# 从字符串创建
list("hello")  # ['h', 'e', 'l', 'l', 'o']

# 从 range 创建
list(range(5))  # [0, 1, 2, 3, 4]

# 乘法复制——⚠️ 有坑！
result = [[0] * 3] * 3  # [[0,0,0], [0,0,0], [0,0,0]]
result[0][0] = 1
print(result)            # [[1,0,0], [1,0,0], [1,0,0]] — 全变了！

fruits = ["苹果", "香蕉", "橘子", "葡萄", "西瓜"]

# 正向索引（从左到右，从 0 开始）
#  索引:  0      1      2      3      4
print(fruits[0])   # 苹果
print(fruits[2])   # 橘子

# 负向索引（从右到左，从 -1 开始）
#  索引: -5     -4     -3     -2     -1
print(fruits[-1])  # 西瓜
print(fruits[-3])  # 橘子

# 可变（Mutable）：列表
lst = [1, 2, 3]
lst[0] = 99      # ✅ 直接修改元素
print(lst)       # [99, 2, 3]

# 不可变（Immutable）：字符串/元组
s = "abc"
# s[0] = "X"    # ❌ TypeError: 'str' object does not support item assignment

t = (1, 2, 3)
# t[0] = 99     # ❌ TypeError: 'tuple' object does not support item assignment

# 情况 1：赋值就是复制引用
a = [1, 2, 3]
b = a            # b 和 a 指向同一个列表对象
b.append(4)
print(a)         # [1, 2, 3, 4] — a 也被改了！
print(a is b)    # True — 同一个对象

# 情况 2：想复制要显式创建新列表
c = a.copy()     # 浅拷贝
# 或用 c = a[:]
# 或用 c = list(a)

c.append(5)
print(a)         # [1, 2, 3, 4] — 不受影响
print(c)         # [1, 2, 3, 4, 5]

# 情况 3：浅拷贝 vs 深拷贝（嵌套列表）
original = [[1, 2], [3, 4]]
shallow = original.copy()
shallow[0][0] = 99
print(original)  # [[99, 2], [3, 4]] — 内层列表共享！

import copy
deep = copy.deepcopy(original)
deep[0][0] = 999
print(original)  # [[99, 2], [3, 4]] — 不受影响

import sys

# 空列表的容量
empty = []
print(sys.getsizeof(empty))  # 56 bytes（仅列表对象本身）

# 每次 append，当容量不够时自动扩容
lst = []
for i in range(10):
    lst.append(i)
    print(f"len={len(lst):2d}, size={sys.getsizeof(lst):4d} bytes")

list[start:stop:step]

nums = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

nums[2:5]        # [2, 3, 4]        — 标准切片
nums[:4]         # [0, 1, 2, 3]     — 从头开始
nums[6:]         # [6, 7, 8, 9]     — 到末尾结束
nums[::2]        # [0, 2, 4, 6, 8]  — 步长为 2（取偶数位）
nums[1::2]       # [1, 3, 5, 7, 9]  — 步长为 2（取奇数位）
nums[::-1]       # [9, 8, 7, 6, 5, 4, 3, 2, 1, 0] — 反转列表
nums[-3:-1]      # [7, 8]           — 负索引切片
nums[-5:-2]      # [5, 6, 7]        — 从倒数第 5 到倒数第 2

original = [1, 2, 3, 4, 5]
sliced = original[1:4]

print(sliced is original)    # False — 不同对象
sliced[0] = 999
print(original)              # [1, 2, 3, 4, 5] — 原始不变
print(sliced)                # [999, 3, 4]

nums = [1, 2, 3, 4, 5]

# 1. 用切片替换部分元素（数量可以不相等！）
nums[1:4] = [10, 20]         # 替换 3 个元素为 2 个
print(nums)                  # [1, 10, 20, 5]

# 2. 用切片删除元素
nums[1:3] = []               # 等价于 del nums[1:3]
print(nums)                  # [1, 5]

# 3. 用切片插入元素
nums[1:1] = [2, 3, 4]       # 在索引 1 处插入（不替换任何元素）
print(nums)                  # [1, 2, 3, 4, 5]

# 4. 用切片清空列表（但保留原对象）
nums[:] = []
print(nums)                  # []

# 5. 复制整个列表
nums = [1, 2, 3]
copy = nums[:]               # 等价于 nums.copy()

# 验证 slice 对象的创建
s = slice(1, 4, None)
print(s)                    # slice(1, 4, None)
print(nums[s])              # 等价于 nums[1:4]

# 命名切片——提高可读性
SLICE_MIDDLE = slice(2, 5)
data = [10, 20, 30, 40, 50, 60]
print(data[SLICE_MIDDLE])   # [30, 40, 50]

tasks = ["写代码", "测试"]

# append — 尾部添加一个元素
tasks.append("部署")
print(tasks)  # ['写代码', '测试', '部署']

# extend — 批量添加（参数必须是可迭代对象）
tasks.extend(["监控", "优化"])
print(tasks)  # ['写代码', '测试', '部署', '监控', '优化']

# 注意 append 和 extend 的区别
tasks.append(["文档", "复盘"])   # 整个列表作为一个元素
print(tasks)
# ['写代码', '测试', '部署', '监控', '优化', ['文档', '复盘']]

tasks.extend(["文档", "复盘"])   # 展开添加
print(tasks)
# ['写代码', '测试', '部署', '监控', '优化', '文档', '复盘']

# insert — 指定位置插入
tasks.insert(0, "规划")         # 插入到开头
print(tasks)
# ['规划', '写代码', '测试', '部署', '监控', '优化', '文档', '复盘']

items = ["a", "b", "c", "b", "d"]

# pop — 栈操作（后进先出）
last = items.pop()
print(last)            # d
print(items)           # ['a', 'b', 'c', 'b']

# pop 指定索引
second = items.pop(1)
print(second)          # b
print(items)           # ['a', 'c', 'b']

# remove — 删除第一个匹配值
items.remove("b")
print(items)           # ['a', 'c'] — 只删第一个 b

# clear — 全部清空
items.clear()
print(items)           # []

scores = [85, 92, 78, 92, 88, 92]

# index — 找索引（不存在抛 ValueError）
print(scores.index(92))        # 1 — 第一个 92 在索引 1

# 指定查找范围
print(scores.index(92, 2))     # 3 — 从索引 2 开始找
print(scores.index(92, 2, 5))  # 3 — 在索引 2~4 范围内找

# count — 统计出现次数
print(scores.count(92))        # 3
print(scores.count(999))       # 0

# in — 成员检查（推荐优先用这个判断存在）
if 78 in scores:
    print("78 分存在！")

numbers = [3, 1, 4, 1, 5, 9, 2, 6]

# sort — 原地排序（修改原列表）
numbers.sort()
print(numbers)  # [1, 1, 2, 3, 4, 5, 6, 9]

numbers.sort(reverse=True)
print(numbers)  # [9, 6, 5, 4, 3, 2, 1, 1]

# sorted — 不修改原列表，返回新列表
original = [3, 1, 4]
sorted_copy = sorted(original)
print(original)       # [3, 1, 4] — 原列表不变
print(sorted_copy)    # [1, 3, 4]

# key 参数排序（高级用法）
words = ["python", "java", "c", "javascript", "go"]
words.sort(key=len)
print(words)  # ['c', 'go', 'java', 'python', 'javascript']

# 按自定义规则
students = [
    {"name": "Alice", "score": 85},
    {"name": "Bob", "score": 92},
    {"name": "Charlie", "score": 78},
]
students.sort(key=lambda s: s["score"], reverse=True)
print(students)
# [{'name': 'Bob', 'score': 92}, {'name': 'Alice', 'score': 85}, {'name': 'Charlie', 'score': 78}]

nums = [3, 1, 4, 1, 5]

print(len(nums))             # 5
print(min(nums))             # 1
print(max(nums))             # 5
print(sum(nums))             # 14
print(any([False, True]))    # True
print(all([True, True]))     # True

# enumerate — 同时拿索引和值
for i, v in enumerate(["a", "b", "c"]):
    print(f"索引 {i} → {v}")

# zip — 拉链式组合
names = ["张三", "李四", "王五"]
scores = [88, 95, 73]
for name, score in zip(names, scores):
    print(f"{name}: {score}")

# 基本形式：[expression for item in iterable]

# 传统写法
squares = []
for x in range(10):
    squares.append(x**2)

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

# 带条件
evens = [x for x in range(20) if x % 2 == 0]
# [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

# 嵌套循环
pairs = [(x, y) for x in [1, 2] for y in [3, 4]]
# [(1, 3), (1, 4), (2, 3), (2, 4)]

# 条件表达式（三元）
labels = ["偶数" if x % 2 == 0 else "奇数" for x in range(5)]
# ['偶数', '奇数', '偶数', '奇数', '偶数']

# ❌ 错误：在迭代列表时删除元素
items = [1, 2, 3, 4, 5, 6]
for item in items:
    if item % 2 == 0:
        items.remove(item)
print(items)  # [1, 3, 5] — 运气好对了，但不可靠

# 更糟的情况
items = [1, 2, 2, 3, 4]
for item in items:
    if item == 2:
        items.remove(item)
print(items)  # [1, 2, 3, 4] — 第二个 2 被跳过了！

# ✅ 正确：遍历副本
for item in items[:]:    # 遍历切片副本
    if item == 2:
        items.remove(item)

# ✅ 更好：列表推导式创建新列表
items = [x for x in items if x != 2]

# ❌ 大坑
def add_task(task, tasks=[]):
    tasks.append(task)
    return tasks

print(add_task("写代码"))   # ['写代码']
print(add_task("测试"))      # ['写代码', '测试'] — 同一个列表！

# ✅ 正确
def add_task(task, tasks=None):
    if tasks is None:
        tasks = []
    tasks.append(task)
    return tasks

# 一维：没问题（int 不可变）
row = [0] * 5
row[0] = 1
print(row)  # [1, 0, 0, 0, 0] — ✅

# 二维：大坑
matrix = [[0] * 3] * 3      # 3 行，每行都是同一个列表
matrix[0][0] = 1
print(matrix)  # [[1, 0, 0], [1, 0, 0], [1, 0, 0]] — ❌

# ✅ 正确创建二维列表
matrix = [[0] * 3 for _ in range(3)]
matrix[0][0] = 1
print(matrix)  # [[1, 0, 0], [0, 0, 0], [0, 0, 0]] — ✅