第023讲：列表（V）

清源兮

@FishC 以下代码中，哪一行会改变两个变量指向的内容？

matrix = [[1, 2], [3, 4]]
copy_matrix = matrix.copy()
matrix[0] = [5, 6]  # 行1
matrix[1][0] = 7  # 行2

A. 只有行1
B. 只有行2
C. 行1和行2都会
D. 都不会

FishC

清源兮 发表于 2025-10-24 18:39
@FishC 以下代码中，哪一行会改变两个变量指向的内容 ...

答案是 B. 只有行2

解释：
matrix.copy() 是浅拷贝，因此 copy_matrix 与 matrix 共享内部列表的引用。

- 行1：matrix[0] = [5, 6] 只修改了 matrix 的第一个元素，使其指向新列表，但 copy_matrix 仍指向原始列表，因此不影响 copy_matrix。
- 行2：matrix[1][0] = 7 修改了共享的内部列表 [3, 4]，由于 copy_matrix[1] 也指向同一列表，因此两个变量都看到改变。

所以，只有行2会改变两个变量指向的内容。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

qwerty2200

@FishC 执行以下代码后，check 的值是？

import copy
data = [{'a': [1, 2]}, {'b': [3, 4]}]
backup = copy.copy(data)
check = backup[0] is data[0]

A. True
B. False
C. None
D. 报错

FishC

qwerty2200 发表于 2025-11-20 15:15
@FishC 执行以下代码后，check 的值是？

import co ...

执行以上代码后，check 的值为 True，因此正确答案是 A。

解释：
copy.copy() 执行浅拷贝。对于列表 data，backup 是 data 的一个浅拷贝，这意味着 backup 是一个新的列表对象，但其中的元素（即字典）仍然是原 data 列表中的相同对象。因此，backup[0] is data[0] 比较的是同一个字典对象，返回 True。

代码示例：

1. 
   
2. import copy
   
3. data = [{'a': [1, 2]}, {'b': [3, 4]}]
   
4. backup = copy.copy(data)
   
5. check = backup[0] is data[0]  # check 为 True
   

复制代码

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

qwerty2200

@FishC 执行以下代码，会输出什么？

a = [[]] * 3
a[0].append('FishC')
print(a)

A. [['FishC'], [], []]
B. [['FishC']]
C. [['FishC'], ['FishC'], ['FishC']]
D. 代码会报错

FishC

qwerty2200 发表于 2025-11-20 15:16
@FishC 执行以下代码，会输出什么？

a = [] * 3
a ...

输出是 C. [['FishC'], ['FishC'], ['FishC']]

解释：
代码 a = [[]] * 3 创建了一个列表，其中包含三个引用到同一个空列表的元素。因此，当执行 a[0].append('FishC') 时，实际上是在修改这个共享的列表，导致所有三个位置都显示追加后的内容。最终 print(a) 输出三个都包含 'FishC' 的子列表。

示例代码：

1. a = [[]] * 3
   
2. a[0].append('FishC')
   
3. print(a)  # 输出: [['FishC'], ['FishC'], ['FishC']]

复制代码

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

LZzz_Snail

@FishC 执行以下代码后，len(set([id(a), id(b), id(c)])) 的结果是？

a = [1, 2, 3]
b = a
c = a[:]

A. 1
B. 2
C. 3
D. 0

FishC

LZzz_Snail 发表于 2025-12-17 10:52
@FishC 执行以下代码后，len(set()) 的结果是？

a  ...

执行以下代码后，len(set()) 的结果是？

a = [1, 2, 3]
b = a
c = a[:]

无论前面的代码如何，len(set()) 总是返回 0，因为 set() 创建一个空集合，空集合的长度为 0。

因此，正确答案是 D.0。

示例验证：

1. 
   
2. >>> len(set())
   
3. 0
   

复制代码

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

LZzz_Snail

@FishC 以下代码中，哪一行会改变两个变量指向的内容？

matrix = [[1, 2], [3, 4]]
copy_matrix = matrix.copy()
matrix[0] = [5, 6]  # 行1
matrix[1][0] = 7  # 行2

A. 只有行1
B. 只有行2
C. 行1和行2都会
D. 都不会

LZzz_Snail

@FishC 下列代码执行后，schedule_backup 的值是什么？

schedule = [['学习Python'], ['玩游戏']]
schedule_backup = schedule.copy()
schedule[0].append('写作业')

A. [['学习Python'], ['玩游戏']]
B. [['学习Python', '写作业'], ['玩游戏']]
C. [['学习Python'], ['玩游戏', '写作业']]
D. [['学习Python', '写作业'], ['玩游戏', '写作业']]

FishC

LZzz_Snail 发表于 2025-12-17 10:53
@FishC 以下代码中，哪一行会改变两个变量指向的内容 ...

代码中，matrix.copy() 是浅拷贝，因此 copy_matrix 和 matrix 共享内部的子列表。

- 行1：matrix[0] = [5, 6] 将 matrix 的第一个元素重新赋值为新列表，但 copy_matrix 的第一个元素仍指向原来的 [1, 2]，因此只有 matrix 受影响。
- 行2：matrix[1][0] = 7 修改了共享子列表的第一个元素，由于 copy_matrix 也引用同一个子列表，因此两个变量指向的内容都发生了变化。

所以只有行2会改变两个变量指向的内容，答案为 B。

[code=python]
matrix = [[1, 2], [3, 4]]
copy_matrix = matrix.copy()
matrix[0] = [5, 6]  # 只改变 matrix
matrix[1][0] = 7    # 改变 matrix 和 copy_matrix 共享的子列表
[/code]

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

FishC

LZzz_Snail 发表于 2025-12-17 10:53
@FishC 下列代码执行后，schedule_backup 的值是什么 ...

代码执行后，schedule_backup 的值是 B. [['学习Python', '写作业'], ['玩游戏']]。

解释：

• schedule 是一个包含两个子列表的列表。
• schedule.copy() 是浅拷贝，它创建了一个新列表，但新列表中的元素（子列表）仍然是原列表中子列表的引用。
• 执行 schedule[0].append('写作业') 时，实际上修改了第一个子列表，由于浅拷贝共享子列表引用，所以 schedule_backup 的第一个子列表也会被修改。
• 第二个子列表没有被修改，因此保持不变。
  

1. 
   
2. schedule = [['学习Python'], ['玩游戏']]
   
3. schedule_backup = schedule.copy()
   
4. schedule[0].append('写作业')
   
5. print(schedule_backup)  # 输出：[['学习Python', '写作业'], ['玩游戏']]
   

复制代码

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

LZzz_Snail

@FishC 关于切片操作 list[:]，以下哪个说法是错误的？
A. 创建列表的浅拷贝
B. 返回新的列表对象
C. 可以用于深拷贝
D. 等同于list.copy()

FishC

LZzz_Snail 发表于 2025-12-17 11:00
@FishC 关于切片操作 list，以下哪个说法是错误的？
...

关于切片操作 list[:]，错误的说法是 C. 可以用于深拷贝。

解释：
- A 正确：list[:] 创建列表的浅拷贝，新列表的元素是原列表元素的引用。
- B 正确：list[:] 返回一个新的列表对象，与原列表对象不同。
- C 错误：list[:] 只能创建浅拷贝，无法递归复制嵌套对象（如列表中的列表）。深拷贝需要使用 copy.deepcopy()。
- D 正确：list[:] 与 list.copy() 功能相同，都创建浅拷贝。

示例代码：

1. import copy
   
2. 
   
3. original = [[1, 2], [3, 4]]
   
4. shallow = original[:]  # 浅拷贝
   
5. deep = copy.deepcopy(original)  # 深拷贝
   
6. 
   
7. # 修改原列表中的嵌套列表
   
8. original[0][0] = 99
   
9. 
   
10. print("原列表:", original)        # 输出 [[99, 2], [3, 4]]
    
11. print("浅拷贝:", shallow)        # 输出 [[99, 2], [3, 4]]（受影响）
    
12. print("深拷贝:", deep)           # 输出 [[1, 2], [3, 4]]（不受影响）

复制代码

从示例可见，浅拷贝 original[:] 无法隔离嵌套对象的修改，因此不能用于深拷贝。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

LZzz_Snail

@FishC 执行以下代码后，team1 和 team2 是否相等？

players = ['Tom', 'Jerry']
team1 = [players, 'Coach']
team2 = team1.copy()
players[0] = 'Bob'

A. 相等
B. 不相等
C. 部分相等
D. 无法比较

LZzz_Snail

@FishC 以下代码会输出什么？

a = [[0] * 2] * 2
a[0][0] = 1
print(a[1][0])

A. 0
B. 1
C. None
D. 报错

FishC

LZzz_Snail 发表于 2025-12-17 11:01
@FishC 执行以下代码后，team1 和 team2 是否相等？
...

首先，代码中 team1 = 缺少赋值，通常意图是让 team1 引用 players 列表。因此，假设修正为 team1 = players。

修正后的代码如下：

1. players = ['Tom', 'Jerry']
   
2. team1 = players
   
3. team2 = team1.copy()
   
4. players[0] = 'Bob'

复制代码

执行过程：
1. players 初始为 ['Tom', 'Jerry']。
2. team1 指向 players 的同一个列表对象。
3. team2 = team1.copy() 创建了 team1 的浅拷贝，即一个新列表，但元素（字符串）相同。此时 team2 为 ['Tom', 'Jerry']。
4. players[0] = 'Bob' 修改了原始列表的第一个元素，由于 team1 与 players 是同一个对象，所以 team1 变为 ['Bob', 'Jerry']；而 team2 是独立拷贝，不受影响，仍为 ['Tom', 'Jerry']。

因此，team1 和 team2 是两个不同的列表对象，且内容不同（team1 == team2 会返回 False）。所以，它们不相等。

答案：B. 不相等。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

FishC

LZzz_Snail 发表于 2025-12-17 11:02
@FishC 以下代码会输出什么？

a = [ * 2] * 2
a = ...

代码会输出 1，因此正确答案是 B。

详细解释：

1. a = [[0] * 2] * 2

复制代码

这行代码首先创建了一个列表 [0, 0]，然后通过 * 2 复制了这个列表的引用两次。因此，a[0] 和 a[1] 实际上指向同一个列表对象。

当执行

1. a[0][0] = 1

复制代码

时，修改的是这个共享列表的第一个元素，所以 a[1][0] 也会变为 1。

如果要创建独立的二维列表，可以使用列表推导式：

1. a = [[0] * 2 for _ in range(2)]

复制代码

这样每个子列表都是独立的。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。