python - with - Zugriff auf den Index in "for"-Schleifen?




python loop through dict with index (14)

Wie kann ich auf den Index selbst zugreifen, um eine Liste wie die folgende zu erhalten?

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

Wie greife ich beim Schleifen mit einer for Schleife auf den Schleifenindex zu, in diesem Fall von 1 bis 5?

https://code.i-harness.com


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

Verwenden Sie enumerate , um den Index mit dem Element während der Iteration abzurufen:

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

Beachten Sie, dass die Python-Indizes bei null beginnen, so dass Sie mit den obigen Werten 0 bis 4 erhalten würden. Wenn Sie die Zählung von 1 bis 5 wünschen, tun Sie dies:

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

Unidiomatischer Kontrollfluss

Nach was Sie fragen, ist das Pythonic-Äquivalent des Folgenden. Dies ist der Algorithmus, den die meisten Programmierer für untergeordnete Sprachen 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

Die enumerate Python reduziert das visuelle Durcheinander, indem die Abrechnung für die Indizes ausgeblendet wird und das iterierbare Element in ein anderes iterierbares Objekt (ein enumerate ) gekapselt wird, das ein Tupel mit zwei Elementen des Index und das Element ergibt, das das ursprüngliche iterable bereitstellt. Das sieht so aus:

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

Dieses Codebeispiel ist ziemlich genau das canonical Beispiel für den Unterschied zwischen Code, der idiomatisch für Python ist, und Code, der nicht ist. Idiomatischer Code ist komplexer (aber nicht komplizierter) Python, der so geschrieben wurde, 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.

Zählen

Selbst wenn Sie keine Indizes benötigen, aber Sie eine Anzahl der Iterationen (manchmal wünschenswert) benötigen, können Sie mit 1 und die endgültige Zahl wird Ihre 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 als das, was Sie erwarten (im Gegensatz zum Index), wenn Sie sagten, Sie wollten 1 bis 5.

Zerlegen - eine schrittweise Erklärung

Um diese Beispiele aufzuschlüsseln, nehmen wir an, wir haben eine Liste von Elementen, die wir mit einem Index durchlaufen möchten:

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

Nun übergeben wir das iterable zum Aufzählen und erstellen ein Aufzählungsobjekt:

enumerate_object = enumerate(items) # the enumerate object

Wir können das erste Element aus diesem iterierbaren Element herausziehen, das wir mit der next Funktion in eine Schleife bringen würden:

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

Und wir sehen, dass wir ein Tupel von 0 , den ersten Index und 'a' , das erste Element erhalten:

(0, 'a')

Wir können das, was als " Sequence Unpacking " bezeichnet wird, verwenden, um die Elemente aus diesem Zwei-Tupel zu extrahieren:

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

und wenn wir den index prüfen, stellen wir fest, dass er sich auf den ersten Index bezieht, 0 und item sich auf den ersten Eintrag, 'a' bezieht.

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

Fazit

  • Python-Indizes beginnen bei Null
  • Verwenden Sie die Enumerate-Funktion, um diese Indizes von einer iterierbaren Funktion abzurufen, wenn Sie darüber iterieren
  • Wenn Sie die Aufzählung auf idiomatische Weise (zusammen mit dem Auspacken des Tupels) verwenden, 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)

Der schnellste Weg zum Zugriff auf Indexe der Liste innerhalb einer Schleife in Python 2.7 besteht darin, die Range-Methode für kleine Listen und die Aufzählungsmethode für Listen mittlerer und großer Größe zu verwenden.

In den folgenden Codebeispielen finden Sie verschiedene Ansätze, mit denen Sie über den Listen- und Zugriffsindexwert und ihre Leistungsmesswerte (die ich für Sie nützlich sein könnte) iterieren können:

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

Siehe Leistungskennzahlen für jede Methode unten:

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 ist die Verwendung der range Methode die schnellste mit 1000 Artikeln. Bei einer Liste mit einer Größe von> 10 000 ist der enumerate der Gewinner.

Nachfolgend einige nützliche Links hinzufügen:


Die beste Lösung für dieses Problem ist die Verwendung der integrierten Python-Funktion.
Aufzählen von Rückgabetupel
erster Wert ist Index
Der zweite Wert ist Element des Arrays an diesem Index

In [1]: ints = [8, 23, 45, 12, 78]

In [2]: for idx, val in enumerate(ints):
   ...:         print(idx, val)
   ...:     
(0, 8)
(1, 23)
(2, 45)
(3, 12)
(4, 78)

Dies ist gut genug:

list1 = [10, 'sumit', 43.21, 'kumar', '43', 'test', 3]
for x in list1:
    print('index:', list1.index(x), 'value:', x)

Gemäß dieser Diskussion: http://bytes.com/topic/python/answers/464012-objects-list-index

Schleifenzähler-Iteration

Das aktuelle Idiom zum Durchlaufen der Indizes verwendet die eingebaute 'Range'-Funktion:

for i in range(len(sequence)):
    # work with index i

Das Durchlaufen beider Elemente und Indizes kann entweder durch die alte Sprache oder durch Verwendung der neuen eingebauten Funktion 'zip' [2] erreicht werden:

for i in range(len(sequence)):
    e = sequence[i]
    # work with index i and element e

oder

for i, e in zip(range(len(sequence)), sequence):
    # work with index i and element e

über http://www.python.org/dev/peps/pep-0212/


Ich weiß nicht, ob das Folgende Pythonic ist oder nicht, aber es verwendet die Python-Funktion, enumerate den Index und den Wert aufführt.

int_list = [8, 23, 45, 12, 78]
for index, value in enumerate(int_list):
   print(index, value)

Ausgabe:

0 8
1 23
2 45
3 12
4 78

Sie haben eine Reihe von Antworten mit Erläuterungen zum enumerate . Wenn Sie jedoch nur den Index für den Zugriff auf übereinstimmende Einträge in zwei Listen benötigen, gibt es in Python 3 einen anderen Weg, der sauberer und einfacher ist: zip .

Wenn Sie beispielsweise den Index verwenden, um die entsprechenden Namen für die Zahlen in Ihrer Liste abzurufen, können Sie dies folgendermaßen tun:

ints = [8, 23, 45, 12, 78]
names = ["John", "Sue", "Johannes", "Patel", "Ian"]
for int, name = zip(ints, names):
    print("{} - {}".format(name, int)

Das würde produzieren

8 - John
23 - Sue
45 - Johannes
12 - Patel
78 - Ian

Sie können die index verwenden

ints = [8, 23, 45, 12, 78]
inds = [ints.index(i) for i in ints]

BEARBEITEN Im Kommentar hervorgehoben, dass diese Methode nicht funktioniert, wenn ints Duplikate ints , sollte die folgende Methode für alle Werte in ints :

ints = [8, 8, 8, 23, 45, 12, 78]
inds = [tup[0] for tup in enumerate(ints)]

Oder alternativ

ints = [8, 8, 8, 23, 45, 12, 78]
inds = [tup for tup in enumerate(ints)]

wenn Sie sowohl den Index als auch den Wert in ints als Liste von Tupeln erhalten ints .

Es verwendet die enumerate in der ausgewählten Antwort auf diese Frage, jedoch mit Listenverständnis, wodurch es mit weniger Code schneller wird.


Sie können es mit diesem Code machen:

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

for value in (ints):
    index +=1
    print index, value

Verwenden Sie diesen Code, wenn Sie den Indexwert am Ende der Schleife zurücksetzen müssen:

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

for value in (ints):
    index +=1
    print index, value
    if index >= len(ints)-1:
        index = 0

Um ein Tupel von (Index, Wert) im Listenverständnis mithilfe einer for Schleife zu drucken:

ints = [8, 23, 45, 12, 78]
print [(i,ints[i]) for i in range(len(ints))]

Ausgabe:

[(0, 8), (1, 23), (2, 45), (3, 12), (4, 78)]

Wenn es keinen doppelten Wert in der Liste gibt:

for i in ints:
        indx=ints.index(i)
        print(i,indx)

Verwenden Sie stattdessen die enumerate.

for counter, value in enumerate(ints):
    print(counter, value)

ODER verwenden Sie unten:

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

Wenn ich Nums = [1,2,3,4,5] durchlaufen würde, würde ich das tun

for i, num in enumerate(nums, start = 1):
    print(i, num)

Oder erhalte die Länge als l = len (nums)

for i, num in range(1, l + 1):
    print(i, nums[i])

Zunächst werden die Indizes von 0 bis 4 sein. Programmiersprachen beginnen mit 0 zu zählen; Vergiss das nicht, oder du wirst einen Index außerhalb der Grenzen finden. Alles, was Sie in der for-Schleife brauchen, ist eine Variable, die von 0 bis 4 zählt.

for x in range(0, 5):

Denken Sie daran, dass ich 0 bis 5 geschrieben habe, weil die Schleife eine Zahl vor dem max stoppt. :)

Um den Wert eines Index zu erhalten, verwenden Sie

list[index]

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




list