Frage Zugriff auf den Index in "for" -Schleifen?


Wie greife ich auf den Index selbst für eine Liste wie folgt zu?

ints = [8, 23, 45, 12, 78]

Wenn ich es mit a durchlaufen werde for Schleife, wie greife ich auf den Schleifenindex von 1 bis 5 in diesem Fall zu?


2560
2018-02-06 22:47


Ursprung


Antworten:


Das Verwenden einer zusätzlichen Statusvariablen, z. B. einer Indexvariablen (die normalerweise in Sprachen wie C oder PHP verwendet wird), wird als nicht pythonisch angesehen.

Die bessere Option ist die integrierte Funktion enumerate(), verfügbar in Python 2 und 3:

for idx, val in enumerate(ints):
    print(idx, val)

Auschecken PEP 279 für mehr.


4444
2018-02-06 22:52



Wie erreiche ich mit einer for-Schleife den Schleifenindex, in diesem Fall von 1 bis 5?

Benutzen enumerate um den Index mit dem Element zu erhalten, wenn Sie iterieren:

for index, item in enumerate(items):
    print(index, item)

Und beachte, dass Pythons Indizes bei Null beginnen, also würdest du mit den obigen Werten 0 bis 4 bekommen. Wenn Sie die Anzahl, 1 bis 5, wollen, tun Sie dies:

for count, item in enumerate(items, start=1):
    print(count, item)

Unidiomatischer Kontrollfluss

Was Sie fragen, ist das Pythonic-Äquivalent des Folgenden, welches der Algorithmus ist, den die meisten Programmierer der unteren Programmiersprachen verwenden würden:

index = 0            # Python's indexing starts at zero
for item in items:   # Python's for loops are a "for each" loop 
    print(index, item)
    index += 1

Oder in Sprachen, die keine for-each-Schleife haben:

index = 0
while index < len(items):
    print(index, items[index])
    index += 1

oder manchmal häufiger (aber unidiomatisch) in Python gefunden:

for index in range(len(items)):
    print(index, items[index])

Verwenden Sie die Aufzählungsfunktion

Pythons enumerate Funktion reduziert das visuelle Durcheinander, indem es die Buchhaltung für die Indizes versteckt und das iterierbare in ein anderes iterbares kapselt (an enumerate object), die ein Zwei-Punkte-Tupel des Indexes und das Element liefert, das das ursprüngliche iterierbare Element bereitstellen würde. Das sieht so aus:

for index, item in enumerate(items, start=0):   # default is zero
    print(index, item)

Dieses Codebeispiel ist ziemlich gut das kanonisch Beispiel für den Unterschied zwischen Code, der Idiomatik von Python ist und Code, der nicht ist. Idiomatischer Code ist ausgefeilter (aber nicht komplizierter) Python, der so geschrieben ist, wie er verwendet werden sollte. Idiomatischer Code wird von den Designern der Sprache erwartet, was bedeutet, dass dieser Code normalerweise nicht nur lesbarer, sondern auch effizienter ist.

Eine Zählung bekommen

Auch wenn Sie keine Indizes benötigen, aber Sie benötigen eine Zählung der Iterationen (manchmal wünschenswert), mit denen Sie beginnen können 1 und die endgültige Zahl wird deine Zählung sein.

for count, item in enumerate(items, start=1):   # default is zero
    print(item)

print('there were {0} items printed'.format(count))

Die Zählung scheint mehr zu sein, was Sie beabsichtigen zu verlangen (im Gegensatz zum Index), als Sie sagten, Sie wollten von 1 bis 5.


Breaking down - eine Schritt für Schritt Erklärung

Um diese Beispiele zu durchbrechen, sagen wir, dass wir eine Liste von Elementen haben, die wir mit einem Index durchlaufen wollen:

items = ['a', 'b', 'c', 'd', 'e']

Jetzt übergeben wir dieses iterable zum Aufzählen und erstellen ein enumerate-Objekt:

enumerate_object = enumerate(items) # the enumerate object

Wir können den ersten Punkt aus diesem iterablen ziehen, den wir mit dem next Funktion:

iteration = next(enumerate_object) # first iteration from enumerate
print(iteration)

Und wir sehen, wir bekommen ein Tupel von 0, der erste Index und 'a', der erste Punkt:

(0, 'a')

wir können verwenden, was als "Sequenz Entpacken"um die Elemente aus diesem Zwei-Tupel zu extrahieren:

index, item = iteration
#   0,  'a' = (0, 'a') # essentially this.

und wenn wir inspizieren index, wir finden es bezieht sich auf den ersten Index, 0, und item bezieht sich auf den ersten Punkt, 'a'.

>>> print(index)
0
>>> print(item)
a

Fazit

  • Python-Indizes beginnen bei Null
  • Verwenden Sie die Enumerate-Funktion, um diese Indizes aus einer iterablen zu erhalten, während Sie darüber iterieren
  • Durch iteratives Aufzählen (zusammen mit dem Tupel-Entpacken) wird Code erstellt, der besser lesbar und wartbar ist:

Also mach das:

for index, item in enumerate(items, start=0):   # Python indexes start at zero
    print(index, item)

516
2018-01-21 17:11



Es ist ziemlich einfach, damit anzufangen 1 außer 0:

for index, item in enumerate(iterable, start=1):
   print index, item

Hinweis

Wichtiger Hinweis, obwohl ein wenig irreführend seit index wird ein ... sein tuple  (idx, item) Hier. Gut zu gehen.


105
2018-05-27 10:04



for i in range(len(ints)):
   print i, ints[i]

67
2018-02-06 22:49



Wie es in Python der Fall ist, gibt es mehrere Möglichkeiten, dies zu tun. In allen Beispielen nehme man an: lst = [1, 2, 3, 4, 5]

1. Mit enumerate (als am idiomatischsten angesehen)

for index, element in enumerate(lst):
    # do the things that need doing here

Dies ist meiner Meinung nach auch die sicherste Option, da die Möglichkeit, in unendliche Rekursion zu gehen, eliminiert wurde. Sowohl der Eintrag als auch sein Index werden in Variablen gespeichert, und es ist nicht erforderlich, weiteren Code zu schreiben um auf den Gegenstand zuzugreifen.

2. Erstellen einer Variablen, um den Index zu halten (verwenden for)

for index in range(len(lst)):   # or xrange
    # you will have to write extra code to get the element

3. Erstellen einer Variablen, um den Index zu halten (verwenden while)

index = 0
while index < len(lst):
    # you will have to write extra code to get the element
    index += 1  # escape infinite recursion

4. Es gibt immer einen anderen Weg

Wie bereits erwähnt, gibt es andere Möglichkeiten, dies zu tun, die hier nicht erläutert wurden, und sie können sogar mehr in anderen Situationen gelten. z.B verwenden itertools.chain mit für. Es behandelt verschachtelte Schleifen besser als die anderen Beispiele.


34
2017-08-15 02:17



Unmodern:

for ix in range(len(ints)):
    print ints[ix]

Listenverständnis:

[ (ix, ints[ix]) for ix in range(len(ints))]

>>> ints
[1, 2, 3, 4, 5]
>>> for ix in range(len(ints)): print ints[ix]
... 
1
2
3
4
5
>>> [ (ix, ints[ix]) for ix in range(len(ints))]
[(0, 1), (1, 2), (2, 3), (3, 4), (4, 5)]
>>> lc = [ (ix, ints[ix]) for ix in range(len(ints))]
>>> for tup in lc:
...     print tup
... 
(0, 1)
(1, 2)
(2, 3)
(3, 4)
(4, 5)
>>> 

20
2018-02-06 22:52



Der schnellste Weg, auf Listenindizes innerhalb von loop in zuzugreifen Python 2.7 ist die Verwendung der Entfernungsmethode für kleine Listen und Methode aufzählen für mittlere und große Größenlisten.

Bitte sehen unterschiedliche Ansätze welches verwendet werden kann, um über die Liste zu iterieren und auf den Indexwert zuzugreifen und ihre Leistungsmetriken (was ich für Sie nützlich sein könnte) in den folgenden Codebeispielen:

from timeit import timeit

# Using range
def range_loop(iterable):
    for i in range(len(iterable)):
        1 + iterable[i]

# Using xrange
def xrange_loop(iterable):
    for i in xrange(len(iterable)):
        1 + iterable[i]

# Using enumerate
def enumerate_loop(iterable):
    for i, val in enumerate(iterable):
        1 + val

# Manual indexing
def manual_indexing_loop(iterable):
    index = 0
    for item in iterable:
        1 + item
        index += 1

Sehen Sie sich die Leistungsmetriken für jede der folgenden Methoden an:

from timeit import timeit

def measure(l, number=10000):
print "Measure speed for list with %d items" % len(l)
print "xrange: ", timeit(lambda :xrange_loop(l), number=number)
print "range: ", timeit(lambda :range_loop(l), number=number)
print "enumerate: ", timeit(lambda :enumerate_loop(l), number=number)
print "manual_indexing: ", timeit(lambda :manual_indexing_loop(l), number=number)

measure(range(1000))
# Measure speed for list with 1000 items
# xrange:  0.758321046829
# range:  0.701184988022
# enumerate:  0.724966049194
# manual_indexing:  0.894635915756

measure(range(10000))
# Measure speed for list with 100000 items
# xrange:  81.4756360054
# range:  75.0172479153
# enumerate:  74.687623024
# manual_indexing:  91.6308541298

measure(range(10000000), number=100)
# Measure speed for list with 10000000 items
# xrange:  82.267786026
# range:  84.0493988991
# enumerate:  78.0344707966
# manual_indexing:  95.0491430759

Als Ergebnis verwenden range Methode ist die schnellste Methode, um mit 1000 Elementen aufzulisten. Für eine Liste mit einer Größe> 10 000 Artikel enumerate ist der Gewinner.

Fügen Sie einige nützliche Links hinzu:


16
2017-08-04 09:49