列表与元组

new_allocated = (ob_size >> 3) + ob_size + 3

import sys

# 同样内容的列表和元组，元组更省内存
lst = [1, 2, 3, 4, 5]
tpl = (1, 2, 3, 4, 5)

print(f"列表内存: {sys.getsizeof(lst)} 字节")  # 104 字节（64 位 CPython）
print(f"元组内存: {sys.getsizeof(tpl)} 字节")  #  88 字节（64 位 CPython）

# ---- 方式 1：字面量 ----
empty = []                                    # 空列表
fruits = ['苹果', '香蕉', '橙子']              # 多元素
mixed = [1, 'Hello', 3.14, True]              # 混合类型
nested = [[1, 2], [3, 4]]                     # 嵌套列表

# ---- 方式 2：list() 构造器 ----
from_range = list(range(1, 6))                # [1, 2, 3, 4, 5]
from_string = list('Python')                  # ['P', 'y', 't', 'h', 'o', 'n']
from_tuple = list((10, 20, 30))               # [10, 20, 30]
from_set = list({3, 1, 2})                    # [1, 2, 3]（顺序不确定）

# ---- 方式 3：列表推导式 ----
squares = [x**2 for x in range(1, 11)]        # [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
evens = [x for x in range(20) if x % 2 == 0]  # [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

# ---- 方式 4：range() 直接转列表 ----
step_list = list(range(0, 20, 3))             # [0, 3, 6, 9, 12, 15, 18]

# ---- 方式 5：* 运算符重复 ----
zeros = [0] * 5                                # [0, 0, 0, 0, 0]

print(f"字面量: {fruits}")
print(f"list(range): {from_range}")
print(f"list(string): {from_string}")
print(f"推导式: {squares}")
print(f"重复: {zeros}")

fruits = ['苹果', '香蕉', '橙子']

# ==================== Create（创建/添加）====================
# append: 末尾追加单个元素
fruits.append('葡萄')                          # ['苹果', '香蕉', '橙子', '葡萄']

# insert: 指定位置插入
fruits.insert(1, '梨')                         # ['苹果', '梨', '香蕉', '橙子', '葡萄']

# extend: 追加可迭代对象的所有元素
fruits.extend(['樱桃', '芒果'])                 # [..., '樱桃', '芒果']

# + 拼接（创建新列表，不修改原列表）
more = fruits + ['西瓜']                        # 新列表，fruits 不变

# ==================== Read（读取）====================
print(fruits[0])                               # '苹果' — 正向索引
print(fruits[-1])                              # '芒果' — 反向索引
print('梨' in fruits)                          # True  — 成员检测
print(fruits.index('橙子'))                     # 3     — 查找索引
print(fruits.count('苹果'))                     # 1     — 计数

# ==================== Update（修改）====================
fruits[1] = '蓝莓'                             # 修改单个元素
fruits[2:4] = ['猕猴桃', '柠檬']                # 切片赋值（替换一段）

# ==================== Delete（删除）====================
fruits.remove('蓝莓')                          # 按值删除（只删第一个匹配）
popped = fruits.pop()                          # 弹出末尾元素，返回被弹出的值
popped_at = fruits.pop(0)                      # 弹出指定索引
del fruits[1]                                  # 按索引删除（不返回值）
fruits[1:3] = []                               # 切片赋空列表 = 删除一段
fruits.clear()                                 # 清空整个列表

print(f"清空后: {fruits}")                       # []

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

# ---- 基础切片 ----
print(nums[2:7])       # [2, 3, 4, 5, 6]   — 索引 2 到 6
print(nums[:5])        # [0, 1, 2, 3, 4]   — 从头到索引 4
print(nums[5:])        # [5, 6, 7, 8, 9]   — 从索引 5 到末尾
print(nums[:])         # [0, 1, 2, ..., 9] — 完整复制

# ---- 步长 ----
print(nums[::2])       # [0, 2, 4, 6, 8]   — 每隔一个取
print(nums[1::3])      # [1, 4, 7]         — 从索引 1 开始，步长 3
print(nums[::-1])      # [9, 8, 7, ..., 0] — 反转
print(nums[::-2])      # [9, 7, 5, 3, 1]   — 反向步长 2

# ---- 切片赋值（修改）----
nums[2:5] = [20, 30]   # 长度可以不同！[0, 1, 20, 30, 5, 6, 7, 8, 9]
print(f"切片赋值: {nums}")

# ---- 切片删除 ----
nums[1:3] = []          # 删除索引 1-2 的元素
print(f"切片删除: {nums}")

# ---- 切片插入 ----
nums[1:1] = [100, 200]  # 在索引 1 处插入（不删除任何元素）
print(f"切片插入: {nums}")

# 基本形式：[表达式 for 变量 in 可迭代对象]
squares = [x**2 for x in range(1, 11)]
print(squares)  # [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

# 带条件过滤：[表达式 for 变量 in 可迭代对象 if 条件]
evens = [x for x in range(1, 21) if x % 2 == 0]
print(evens)  # [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

# 表达式中使用条件：[值1 if 条件 else 值2 for 变量 in 可迭代对象]
labels = ['偶' if x % 2 == 0 else '奇' for x in range(5)]
print(labels)  # ['偶', '奇', '偶', '奇', '偶']

# 嵌套推导式：相当于嵌套 for 循环
# [expr for x in iter1 for y in iter2]
pairs = [(x, y) for x in range(3) for y in range(3)]
print(pairs)
# [(0,0), (0,1), (0,2), (1,0), (1,1), (1,2), (2,0), (2,1), (2,2)]

# 等价的 for 循环写法（对比理解）
pairs_for = []
for x in range(3):
    for y in range(3):
        pairs_for.append((x, y))
# 结果相同

# 实际应用：展平二维列表
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flat = [num for row in matrix for num in row]
print(flat)  # [1, 2, 3, 4, 5, 6, 7, 8, 9]

# 列表推导式：立即创建完整列表，占用内存
list_comp = [x**2 for x in range(1000000)]

# 生成器表达式：惰性求值，几乎不占内存
gen_expr = (x**2 for x in range(1000000))

print(type(list_comp))  # <class 'list'>
print(type(gen_expr))   # <class 'generator'>

# 生成器可以传给 sum/max/min 等函数，无需先创建列表
total = sum(x**2 for x in range(100))  # 省内存
print(total)  # 328350

# ---- list.sort()：原地排序，返回 None ----
nums = [3, 1, 4, 1, 5, 9, 2, 6]
result = nums.sort()                # 原地修改
print(f"sort() 返回值: {result}")    # None
print(f"排序后列表: {nums}")          # [1, 1, 2, 3, 4, 5, 6, 9]

# ---- sorted()：返回新列表，不修改原序列 ----
nums = [3, 1, 4, 1, 5, 9, 2, 6]
new_nums = sorted(nums)
print(f"sorted() 返回值: {new_nums}")  # [1, 1, 2, 3, 4, 5, 6, 9]
print(f"原列表不变: {nums}")            # [3, 1, 4, 1, 5, 9, 2, 6]

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

# ---- 自定义排序键 ----
words = ['banana', 'pie', 'Washington', 'book']
words.sort(key=len)                  # 按长度排序
print(f"按长度: {words}")              # ['pie', 'book', 'banana', 'Washington']

words.sort(key=str.lower)            # 忽略大小写
print(f"忽略大小写: {words}")          # ['banana', 'book', 'pie', 'Washington']

# ---- sorted() 可用于任何可迭代对象 ----
print(sorted('python'))              # ['h', 'n', 'o', 'p', 't', 'y']
print(sorted({3, 1, 2}))             # [1, 2, 3]
print(sorted((9, 5, 2)))             # [2, 5, 9]

# ---- 空元组 ----
empty = ()

# ---- 多元素元组 ----
colors = ('红色', '绿色', '蓝色')

# ---- 单元素元组（注意末尾逗号！）----
single = (1,)          # 元组
not_tuple = (1)        # 整数！括号被当作数学运算符

print(type(single))    # <class 'tuple'>
print(type(not_tuple)) # <class 'int'>

# ---- tuple() 构造器 ----
from_list = tuple([1, 2, 3])       # (1, 2, 3)
from_string = tuple('ABC')         # ('A', 'B', 'C')
from_range = tuple(range(3))       # (0, 1, 2)

# ---- 省略括号（元组打包）----
coordinates = 120.15, 30.28        # 等价于 (120.15, 30.28)
print(type(coordinates))           # <class 'tuple'>

# ---- 基本解包 ----
point = (3, 5)
x, y = point
print(f"x={x}, y={y}")  # x=3, y=5

# ---- 交换变量（Pythonic！）----
a, b = 10, 20
a, b = b, a
print(f"a={a}, b={b}")  # a=20, b=10

# ---- 扩展解包（* 运算符）----
first, *rest = (1, 2, 3, 4, 5)
print(f"first={first}, rest={rest}")  # first=1, rest=[2, 3, 4, 5]

*init, last = (1, 2, 3, 4, 5)
print(f"init={init}, last={last}")    # init=[1, 2, 3, 4], last=5

head, *middle, tail = (1, 2, 3, 4, 5)
print(f"head={head}, middle={middle}, tail={tail}")
# head=1, middle=[2, 3, 4], tail=5

# ---- 嵌套解包 ----
record = ('Alice', 25, (120.15, 30.28))
name, age, (lon, lat) = record
print(f"{name}, {age}岁, 经度{lon}纬度{lat}")

from collections import namedtuple

# 定义命名元组类型
Point = namedtuple('Point', ['x', 'y'])
Color = namedtuple('Color', 'red green blue')

# 创建实例
p = Point(3, 5)
c = Color(255, 128, 0)

# 通过名字访问（比索引更清晰）
print(f"x={p.x}, y={p.y}")           # x=3, y=5
print(f"红={c.red}, 绿={c.green}")    # 红=255, 绿=128

# 仍然支持索引访问
print(p[0])  # 3
print(p[1])  # 5

# 解包
x, y = p
print(f"解包: x={x}, y={y}")

# _asdict() 转为字典
print(p._asdict())  # {'x': 3, 'y': 5}

# _replace() 创建新实例（元组不可变，只能创建新的）
p2 = p._replace(x=10)
print(p2)  # Point(x=10, y=5)

# 元组可哈希 → 可作字典键
locations = {
    ('北京', 39.90, 116.40): "中国首都",
    ('东京', 35.68, 139.69): "日本首都",
}
print(locations[('北京', 39.90, 116.40)])  # 中国首都

# 列表不可哈希 → 不能作字典键
try:
    bad = {[1, 2]: "value"}
except TypeError as e:
    print(f"错误: {e}")  # unhashable type: 'list'

# 注意：元组内含可变元素时也不可哈希
try:
    bad = {([1, 2],): "value"}
except TypeError as e:
    print(f"错误: {e}")  # unhashable type: 'list'

import copy

# ==================== 赋值（不是拷贝！）====================
original = [1, 2, 3]
ref = original              # 只是多了一个引用，指向同一个对象
ref.append(4)
print(f"原列表被修改: {original}")  # [1, 2, 3, 4] — 两个变量指向同一列表

# ==================== 浅拷贝 ====================
original = [1, 2, 3]
shallow1 = original.copy()          # 方法 1：list.copy()
shallow2 = original[:]              # 方法 2：切片
shallow3 = list(original)           # 方法 3：list() 构造器
shallow4 = copy.copy(original)      # 方法 4：copy.copy()

shallow1.append(99)
print(f"浅拷贝互不影响: {original}")  # [1, 2, 3] — 原列表不变

# 但！浅拷贝只复制最外层，内部的可变对象仍然是共享的
nested = [[1, 2], [3, 4]]
shallow_nested = nested.copy()
shallow_nested[0].append(5)
print(f"浅拷贝内部被修改: {nested}")  # [[1, 2, 5], [3, 4]] — 原列表也被改了！

# ==================== 深拷贝 ====================
nested = [[1, 2], [3, 4]]
deep = copy.deepcopy(nested)
deep[0].append(5)
print(f"深拷贝互不影响: {nested}")    # [[1, 2], [3, 4]] — 原列表不变

# ---- 错误写法 ----
matrix = [[0] * 3] * 3       # 看似 3×3 矩阵
matrix[0][0] = 1
print(matrix)                 # [[1, 0, 0], [1, 0, 0], [1, 0, 0]]
# 三行都变了！因为 * 3 复制的是引用，三个内层列表是同一个对象

# ---- 正确写法 ----
matrix = [[0] * 3 for _ in range(3)]  # 每行独立创建
matrix[0][0] = 1
print(matrix)                 # [[1, 0, 0], [0, 0, 0], [0, 0, 0]]

# 验证：错误写法中三行是同一个对象
bad = [[0] * 3] * 3
print(bad[0] is bad[1])       # True — 同一个对象！

good = [[0] * 3 for _ in range(3)]
print(good[0] is good[1])     # False — 不同对象

# ---- 错误写法 ----
nums = [1, 2, 2, 3, 4]
for num in nums:
    if num == 2:
        nums.remove(num)
print(nums)  # [1, 2, 3, 4] — 漏删了一个！

# 原因：删除第 1 个 2 后，列表变为 [1, 2, 3, 4]
# 迭代器已经前进到索引 1，此时索引 1 是第二个 2
# 但第二个 2 已经"滑"到了第一个 2 的位置，迭代器跳过了它

# ---- 正确写法 1：列表推导式（推荐）----
nums = [1, 2, 2, 3, 4]
nums = [num for num in nums if num != 2]
print(nums)  # [1, 3, 4]

# ---- 正确写法 2：反向遍历 ----
nums = [1, 2, 2, 3, 4]
for i in range(len(nums) - 1, -1, -1):
    if nums[i] == 2:
        nums.pop(i)
print(nums)  # [1, 3, 4]

# ---- 正确写法 3：while 循环 ----
nums = [1, 2, 2, 3, 4]
while 2 in nums:
    nums.remove(2)
print(nums)  # [1, 3, 4]

import copy

# 浅拷贝只复制最外层
data = [[1, 2], [3, 4], {'a': 5}]
shallow = data.copy()

# 修改内层列表 → 原数据也被修改
shallow[0].append(99)
print(data[0])    # [1, 2, 99] — 被影响了！

# 修改内层字典 → 原数据也被修改
shallow[2]['b'] = 6
print(data[2])    # {'a': 5, 'b': 6} — 被影响了！

# 修改外层（替换元素）→ 原数据不受影响
shallow[1] = [30, 40]
print(data[1])    # [3, 4] — 没变

# 深拷贝递归复制所有层级
data = [[1, 2], [3, 4], {'a': 5}]
deep = copy.deepcopy(data)
deep[0].append(99)
deep[2]['b'] = 6
print(data[0])    # [1, 2] — 没变
print(data[2])    # {'a': 5} — 没变

# ---- 错误写法 ----
def append_to(item, target=[]):   # 默认值在函数定义时创建，只创建一次！
    target.append(item)
    return target

print(append_to(1))  # [1]
print(append_to(2))  # [1, 2] — 不是 [2]！默认列表被复用了

# ---- 正确写法 ----
def append_to(item, target=None):  # 用 None 作为哨兵值
    if target is None:
        target = []                # 每次调用都创建新列表
    target.append(item)
    return target

print(append_to(1))  # [1]
print(append_to(2))  # [2] — 正确

# ---- 对列表：+= 等价于 extend（原地修改）----
a = [1, 2, 3]
b = a
a += [4]              # 原地修改，a 和 b 仍指向同一对象
print(a is b)          # True
print(a)               # [1, 2, 3, 4]

# ---- 对比：+ 创建新对象 ----
a = [1, 2, 3]
b = a
a = a + [4]            # 创建新列表，a 指向新对象
print(a is b)          # False
print(a)               # [1, 2, 3, 4]
print(b)               # [1, 2, 3] — b 不受影响

# ---- 对元组：+= 创建新对象（因为元组不可变）----
t = (1, 2, 3)
t2 = t
t += (4,)              # 元组不可变，+= 只能创建新对象
print(t is t2)         # False
print(t)               # (1, 2, 3, 4)

original = [3, 1, 2, 3, 2, 4]

# 保持顺序（推荐）
unique = list(dict.fromkeys(original))  # [3, 1, 2, 4]

# 不需要顺序
unique = list(set(original))             # 顺序不确定

t = (1, [2, 3])
t[1].append(4)   # 合法 — 修改的是列表的内容，不是元组的引用
# t[0] = 5       # 非法 — 试图替换元组的元素
# t[1] = [5]     # 非法 — 试图替换元组的元素