迭代器中的Python反向列表

我希望从嵌套列表列表中创建两个词典：

M = {index of list: list}

N = {index of list: reversed list}

例如：

首先，我有以下清单：

L =  [[20, 56], [23, 24], [23, 12], [22, 21], [26, 48], [26, 24]]

因此，最终结果将是：

M = {0: [56, 20], 1: [24, 23], 2: [12, 23], 3: [21, 22], 4: [48, 26], 5: [24, 26]}
N = {0: [20, 56], 1: [23, 24], 2: [23, 12], 3: [22, 21], 4: [26, 48], 5: [26, 24]}

我已经试过了：

M = {}
N = {}
for index, pair in enumerate(L):
    M[index] = pair
    N[index] = pair.reverse()

但其结果是：

M = {0: [56, 20], 1: [24, 23], 2: [12, 23], 3: [21, 22], 4: [48, 26], 5: [24, 26]}
N = {0: [56, 20], 1: [24, 23], 2: [12, 23], 3: [21, 22], 4: [48, 26], 5: [24, 26]}

我通过以下方式解决了这个问题：

N[index] = pair[::-1]

---

但是有人能告诉我为什么会发生这种情况吗？

列表。反转是一种就地操作，因为两个dict中的键指向同一个对象，所以所有引用都会受到影响

>>> a = [1, 2, 3]
>>> b = a
>>> a.reverse()
>>> a
[3, 2, 1]
>>> b
[3, 2, 1]

要获取列表的新反转副本，可以使用
a[：-1]
或
list（反转（a））

但是
a[：：-1]
应该总是优先于
list（reversed（a））
如果你想要一个反向列表，如果你想要一个迭代器，那么就选择
reversed（a）
列表。reverse
是一个就地操作，因为两个dict中的键都指向同一个对象，所以所有引用都会受到影响

>>> a = [1, 2, 3]
>>> b = a
>>> a.reverse()
>>> a
[3, 2, 1]
>>> b
[3, 2, 1]

要获取列表的新反转副本，可以使用
a[：-1]
或
list（反转（a））

但是
a[：：-1]
应该总是优先于
list（reversed（a））
如果你想要一个反向列表，如果你想要一个迭代器，就去@hcwhsa
list提到的
reversed（a）
。reverse
将执行一个就地修改列表的操作。如果您不想就地执行，可以执行以下操作：

>>> l[::-1]
[3, 2, 1]
>>> l
[1, 2, 3]

如@hcwhsa
list所述。reverse
将在适当的位置执行修改列表的操作。如果您不想就地执行，可以执行以下操作：

>>> l[::-1]
[3, 2, 1]
>>> l
[1, 2, 3]

以相反顺序获取列表/字符串/元组的另一种方法是[：-1]。它将从最后一个元素返回到第一个元素，作为一个副本，而不修改a。
以相反顺序获取列表/字符串/元组的另一种方法是[：-1]。它将a的元素作为副本从最后一个返回到第一个，而不修改a。
我不确定我是否相信您的结果
.reverse（）
执行相应操作并返回
None
，因此您不应该得到
N={0:None，1:None，2:None，3:None，4:None，5:None}
？我不确定我是否相信您的结果
.reverse（）
执行相应操作并返回
None
，因此您不应该得到
N={0:None，1:None，2:None，3:None，4:None，5:None}
？好的，明白了。我忘了python中的名称和对象是不一样的。我忘了在python中名称和对象是不同的。