Python仅枚举反向索引

我试图反转

enumerate

给出的索引，同时保留被枚举列表的原始顺序

假设我有以下几点：

>> range(5)
[0, 1, 2, 3, 4]

>> list(enumerate(range(5)))
[(0, 0), (1, 1), (2, 2), (3, 3), (4, 4)]

如果我列举这些，我将得到以下结果：

>> range(5)
[0, 1, 2, 3, 4]

>> list(enumerate(range(5)))
[(0, 0), (1, 1), (2, 2), (3, 3), (4, 4)]

但是，我想反转enumerate提供的索引，以便获得：

[(4, 0), (3, 1), (2, 2), (1, 3), (0, 4)]

到目前为止，我有以下代码：

reversed(list(enumerate(reversed(range(5)))))

---

我只是想知道是否有更简洁的方法可以做到这一点？

只需将列表的长度减去索引即可

L = range(5)

for i, n in L:
    my_i = len(L) -1 - i
    ...

或者，如果您确实需要发电机：

def reverse_enumerate(L):
   # Only works on things that have a len()
   l = len(L)
   for i, n in enumerate(L):
       yield l-i-1, n

def reverse_enum(lst):
    for j, item in enumerate(lst):
        yield len(lst)-1-j, item

print list(reverse_enum(range(5)))
# [(4, 0), (3, 1), (2, 2), (1, 3), (0, 4)]

---

enumerate（）

不可能做到这一点，因为它与泛型迭代器一起工作。例如，您可以向它传递无限迭代器，这些迭代器甚至没有“反向索引”。

使用zip代替反向范围如何

>>> zip(range(9, -1, -1), range(10))
[(9, 0), (8, 1), (7, 2), (6, 3), (5, 4), (4, 5), (3, 6), (2, 7), (1, 8), (0, 9)]


>>> def reversedEnumerate(l):
        return zip(range(len(l)-1, -1, -1), l)
>>> reversedEnumerate(range(10))
[(9, 0), (8, 1), (7, 2), (6, 3), (5, 4), (4, 5), (3, 6), (2, 7), (1, 8), (0, 9)]

正如@julienSpronk所建议的，使用

izip

获取生成器，也可以使用

xrange

：

import itertools
>>> import itertools
>>> def reversedEnumerate(l):
...     return itertools.izip(xrange(len(l)-1, -1, -1), l)
...     
>>> reversedEnumerate(range(10))
<itertools.izip object at 0x03749760>
>>> for i in reversedEnumerate(range(10)):
...     print i
...     
(9, 0)
(8, 1)
(7, 2)
(6, 3)
(5, 4)
(4, 5)
(3, 6)
(2, 7)
(1, 8)
(0, 9)

导入itertools
>>>进口itertools
>>>def反向消耗量（l）：
...     返回itertools.izip（x范围（len（l）-1，-1，-1），l）
...     
>>>反向消耗率（范围（10））
>>>对于倒数第i个数值（范围（10））：
...     打印i
...     
(9, 0)
(8, 1)
(7, 2)
(6, 3)
(5, 4)
(4, 5)
(3, 6)
(2, 7)
(1, 8)
(0, 9)

我不知道这个解决方案是否更适合您，但至少它更短：

>>> [(4 - x, x) for x in range(5)]
[(4, 0), (3, 1), (2, 2), (1, 3), (0, 4)]

---

假设您的列表不长并且不会遇到性能错误，您可以使用

list（枚举（范围（5）[：：-1]）[：：-1]

测试：

列表（枚举（范围（5）[：-1]））[：-1]

---

[（0,4），（1,3），（2,2），（3,1），（4,0）]

实际上我使用的逻辑与@RemcoGerlich相同，但我直接使用了

列表理解

，这使得代码现在变成了一行：

def generatelist(x):
    return [(x-1-i,n) for i,n in enumerate(range(x))]

关于选择

生成器

或

列表理解

的困境，建议的方法是：

基本上，如果只进行一次迭代，则使用生成器表达式。如果您想存储和使用生成的结果，那么最好使用列表理解

---

如果要多次重复使用，您可以制作自己的发电机：

def reverse_enumerate(L):
   # Only works on things that have a len()
   l = len(L)
   for i, n in enumerate(L):
       yield l-i-1, n

def reverse_enum(lst):
    for j, item in enumerate(lst):
        yield len(lst)-1-j, item

print list(reverse_enum(range(5)))
# [(4, 0), (3, 1), (2, 2), (1, 3), (0, 4)]

或

只要在我使用的任何地方使用

len（lst）-i

。或：

[(len(range(5)) - x, x) for x in range(5)]

Python 2 Python 3

---

用

itertools.izip

替换

zip

：）

说明：

values = 'abcde'

values_len = len(values) # 5
indexes = range(values_len) # [0, 1, 2, 3, 4]
reversed_indexes = reversed(indexes) # [4, 3, 2, 1, 0]

# combine reversed indexes and values
reversed_enumerator = zip(reversed_indexes, values)

for i, value in reversed_enumerator:
    print(i, value)

---

我们可以将enumerate与len一起使用：

$ cat enumerate.py 


arr = ['stone', 'cold', 'steve', 'austin']
for i, val in enumerate(arr):
    print ("enu {} val {}".format(i, val))
for i, val in enumerate(arr):
    print ("enu {} val {}".format(len(arr) - i - 1, val))
$  python enumerate.py 
enu 0 val stone
enu 1 val cold
enu 2 val steve
enu 3 val austin
enu 3 val stone
enu 2 val cold
enu 1 val steve
enu 0 val austin
$  

---

或者

itertools.izip

来获取generatorI，我认为这是最简洁的方法。然而，这个问题有点趣味。他希望索引被反转，而不是Listoop！正确的。修好了，我也会这么做。我个人甚至不关心最后一个倒装……请描述您更改了什么以及为什么更改，以帮助其他人识别问题并理解此答案

-（I+1）

或

-1-I

。