Python aufzählen reverse-index nur

Bin ich versucht, umzukehren, den index gegeben durch enumerate unter Beibehaltung der ursprünglichen Reihenfolge der Liste aufgezählt werden.

Angenommen ich habe Folgendes:

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

Wenn ich aufzählen, dies würde ich Folgendes erhalten:

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

Möchte ich aber Umgekehrt den index zur Verfügung gestellt, indem Sie auflisten, so dass ich erhalte:

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

Bisher habe ich folgenden code:

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

Ich wurde gerade gefragt ob es ein eleganter Weg, dies zu tun?

InformationsquelleAutor rozzy | 2016-08-03

Wie über die Verwendung von zip-statt mit einem umgekehrten Bereich?

>>> 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)]

Als @julienSpronk schlägt vor, die Verwendung izip um einen generator, auch 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)

Auch eine nette Idee.
oder itertools.izip um einen generator
Danke! Ich vergesse immer über Reißverschluss!

InformationsquelleAutor Netwave

4

Ich weiß nicht, ob diese Lösung für Sie besser ist, aber zumindest ist es kürzer:
```
>>> [(4 - x, x) for x in range(5)]
[(4, 0), (3, 1), (2, 2), (1, 3), (0, 4)]
```
InformationsquelleAutor mandrewcito
3

Nehmen Sie einfach die Länge Ihrer Liste und subtrahieren Sie den index aus, dass...
```
L = range(5)

for i, n in L:
    my_i = len(L) -1 - i
    ...
```
Oder wenn Sie wirklich brauchen einen generator:
```
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
```
enumerate() können möglicherweise nicht diese, wie es funktioniert generische Iteratoren. Zum Beispiel, können Sie geben Sie unendliche Iteratoren, dass nicht einmal eine "reverse index".

InformationsquelleAutor RemcoGerlich
3

Angenommen, Ihre Liste ist nicht lang, und Sie wird nicht ausgeführt, in performance-Fehler, nutzen Sie list(enumerate(range(5)[::-1]))[::-1].

Test:

>>> list(enumerate(range(5)[::-1]))[::-1] [(0, 4), (1, 3), (2, 2), (3, 1), (4, 0)]
- bitte Lesen Sie sorgfältig, was er verlangt
- Sofern ich die meisten eleganter Weg, dies zu tun, wie ich es verstanden habe. Aber diese Frage ist eine Art von Geschmack.
- er will, dass die Indizes vertauscht werden, nicht die Liste
- Oops! Recht. behoben.
- Dies ist, was ich tun würde, wie gut. Ich persönlich würde noch nicht einmal Gedanken über die letzten reverse...
InformationsquelleAutor Emil
2

Eigentlich bin ich mit der gleichen Logik wie @RemcoGerlich hast, aber ich benutze list comprehension direkt, die machen den code nun 1-liner:
```
def generatelist(x):
    return [(x-1-i,n) for i,n in enumerate(range(x))]
```
In Bezug auf das dilemma der Wahl generator oder list comprehension, hier ist die vorgeschlagene Art und Weise:

Grundsätzlich einen generator-Ausdruck, wenn alles, was Sie tun, ist die Iteration einmal. Wenn Sie möchten, zu speichern und zu verwenden, die generierten Ergebnisse, dann sind Sie wahrscheinlich besser dran mit einer Liste erfassen.

InformationsquelleAutor MaThMaX

Wenn du gehst, zu re-verwenden Sie es mehrmals, können Sie Ihre eigenen generator:

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)]

oder

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

InformationsquelleAutor Julien Spronck

0

Verwenden Sie einfach len(lst)-i überall, wo ich verwendet. oder:
```
[(len(range(5)) - x, x) for x in range(5)]
```
InformationsquelleAutor John

Python 2

import itertools

def reversed_enumerate(seq):
    return itertools.izip(reversed(range(len(seq))), reversed(seq))

Python 3

Ersatz zip für itertools.izip 🙂

InformationsquelleAutor tzot

values = 'abcde'

for i, value in zip(reversed(range(len(values))), values):
    print(i, value)

Erklärung:

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)

Beschreiben Sie bitte, was hast du ändern und warum, um anderen zu helfen, das problem zu identifizieren und zu verstehen, diese Antwort

InformationsquelleAutor Alexander Fedorov

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.