Python列表引用与循环结构：深度解析可变类型与内存机制

# 初始化一个字符串和列表
some_str = "Hello"
some_list_1 = ["Hello"]

# 初始化一个空列表，并将上述两个变量添加进去
some_list_2 = []
some_list_2.append(some_str)   # some_list_2[0] 引用 some_str
some_list_2.append(some_list_1) # some_list_2[1] 引用 some_list_1

print("--- 初始引用状态 ---")
print(f"some_str 的值: {some_str}, ID: {id(some_str)}")
print(f"some_list_1 的值: {some_list_1}, ID: {id(some_list_1)}")
print(f"some_list_2[0] 的值: {some_list_2[0]}, ID: {id(some_list_2[0])}, 与 some_str ID相同?: {id(some_list_2[0]) == id(some_str)}")
print(f"some_list_2[1] 的值: {some_list_2[1]}, ID: {id(some_list_2[1])}, 与 some_list_1 ID相同?: {id(some_list_2[1]) == id(some_list_1)}")

# 修改原始变量
some_str += " World"         # 修改不可变字符串，会创建新对象
some_list_1.append("World") # 修改可变列表，在原地修改

print("\n--- 修改原始变量后 ---")
print(f"some_str 新值: {some_str}, 新ID: {id(some_str)}")
print(f"some_list_1 新值: {some_list_1}, 新ID: {id(some_list_1)}") # ID不变

print(f"some_list_2[0] 的值: {some_list_2[0]}, ID: {id(some_list_2[0])}, 与 some_str 新ID相同?: {id(some_list_2[0]) == id(some_str)}")
print(f"some_list_2[1] 的值: {some_list_2[1]}, ID: {id(some_list_2[1])}, 与 some_list_1 新ID相同?: {id(some_list_2[1]) == id(some_list_1)}")

--- 初始引用状态 ---
some_str 的值: Hello, ID: 4321089264
some_list_1 的值: ['Hello'], ID: 4322442880
some_list_2[0] 的值: Hello, ID: 4321089264, 与 some_str ID相同?: True
some_list_2[1] 的值: ['Hello'], ID: 4322442880, 与 some_list_1 ID相同?: True

--- 修改原始变量后 ---
some_str 新值: Hello World, 新ID: 4322509360
some_list_1 新值: ['Hello', 'World'], 新ID: 4322442880
some_list_2[0] 的值: Hello, ID: 4321089264, 与 some_str 新ID相同?: False
some_list_2[1] 的值: ['Hello', 'World'], ID: 4322442880, 与 some_list_1 新ID相同?: True

a = [1, 2, 3]
b = [4, 5]

# 步骤1: 将列表 b 作为元素添加到列表 a 中
a.append(b)
# 此时，a 变为 [1, 2, 3, [4, 5]]。注意，a[3] 并不是 b 的副本，而是对 b 的引用。
print(f"a: {a}") # 输出: a: [1, 2, 3, [4, 5]]
print(f"b: {b}") # 输出: b: [4, 5]
print(f"a[3] is b: {a[3] is b}") # 验证 a[3] 和 b 是否是同一个对象，输出 True

# 访问 a[3] 的第二个元素（索引1）
print(f"a[3][1]: {a[3][1]}") # a[3] 实际上就是 b，所以 a[3][1] 等同于 b[1]，输出 5

a = [1, 2, 3]
b = [4, 5]
a.append(b) # a: [1, 2, 3, <ref_to_b>]

# 步骤2: 将列表 a 作为元素添加到列表 b 中
b.append(a) # b: [4, 5, <ref_to_a>]
# 此时，a 包含 b 的引用，b 又包含 a 的引用，形成了一个循环引用。
# 内存状态大致为：a -> [..., b], b -> [..., a]

print(f"a: {a}") # 输出: a: [1, 2, 3, [4, 5, [...]]]
print(f"b: {b}") # 输出: b: [4, 5, [1, 2, 3, [...]]]
# Python 在打印循环引用时，会使用 [...] 来表示已经遇到过的引用，避免无限递归打印。

# 验证 b[2] 的第二个元素（索引1）
# b[2] 是对 a 的引用，所以 b[2][1] 等同于 a[1]
print(f"b[2][1]: {b[2][1]}") # 输出 2

# 步骤3: 修改 b 的元素
# a[3] 是对 b 的引用，所以 a[3][1] 就是 b[1]。
# 将 b[1] 从 5 修改为 6。
a[3][1] = 6
# 此时 b 变为 [4, 6, <ref_to_a>]
print(f"修改后 a: {a}") # 输出: a: [1, 2, 3, [4, 6, [...]]]
print(f"修改后 b: {b}") # 输出: b: [4, 6, [1, 2, 3, [...]]]

# 验证对象身份
# a[3] 是 b
# a[3][2] 是 b[2]，而 b[2] 是 a
# 所以 a[3][2] 就是 a 本身
print(f"a[3][2] is a: {a[3][2] is a}") # 输出 True (因为它们是同一个对象)

# 更复杂的路径验证
# b[2] 是 a
# b[2][3] 是 a[3]，而 a[3] 是 b
# b[2][3][2] 是 b[2]，而 b[2] 是 a
# 所以 b[2][3][2] 就是 a 本身
print(f"b[2][3][2] == a: {b[2][3][2] == a}") # 输出 True (因为它们的值相等，且是同一个对象)