it-swarm.com.de

Zugriff auf den Index in "for" -Schleifen?

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 von 1 bis 5 zu?

2916
Joan Venge

Die Verwendung einer zusätzlichen Zustandsvariablen, beispielsweise einer Indexvariablen (die Sie normalerweise in Sprachen wie C oder PHP verwenden würden) wird als Nicht-Pythonic betrachtet.

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

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

Check out PEP 279 für mehr.

5061
Mike Hordecki

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 der 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 Funktion Python's enumerate reduziert die visuelle Unordnung, indem die Abrechnung für die Indizes ausgeblendet wird und das Iterable in ein anderes iterierbares Objekt (ein enumerate-Objekt) eingebettet wird, das einen 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 gut das kanonische 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 beginnen 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 (im Gegensatz zum Index) verlangen würden, 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 Funktion next in eine Schleife bringen würden:

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

Und wir sehen, wir bekommen einen Tupel von 0, dem ersten Index und 'a', dem ersten Element:

(0, 'a')

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

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

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

>>> 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
  • Durch die Verwendung von Enumerate auf idiomatische Weise (zusammen mit dem Auspacken von Tuple) wird Code erstellt, der besser lesbar und wartungsfreundlicher ist:

Also mach das:

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

Es ist ziemlich einfach, es von 1 zu starten, außer von 0:

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

Hinweis

Wichtiger Hinweis, wenn auch etwas irreführend, da index hier eine Tuple(idx, item) ist .

118
Clayton
for i in range(len(ints)):
   print i, ints[i]
76
David Hanak

Wie in Python üblich, gibt es mehrere Möglichkeiten, dies zu tun. In allen Beispielen wird angenommen: lst = [1, 2, 3, 4, 5]

1. Verwenden der Aufzählung ( als am meisten idiomatisch betrachtet)

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 einer unendlichen Rekursion beseitigt wurde. Sowohl das Element als auch sein Index werden in Variablen gehalten und es ist kein weiterer Code erforderlich, um auf das Element zuzugreifen.

2. Erstellen einer Variablen für den Index ( mit for)

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

3. Erstellen einer Variablen für den Index ( mit 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 zuvor erläutert, gibt es andere Möglichkeiten, die hier nicht erläutert wurden, und sie können in anderen Situationen sogar noch mehr zutreffen. z.B. Verwendung von itertools.chain mit für. Es behandelt geschachtelte Schleifen besser als die anderen Beispiele.

40
Charitoo

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)
>>> 
23
Charlie Martin

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

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
18
user2912389

Der schnellste Weg, auf Listenindizes innerhalb der Schleife in Python 2.7 zuzugreifen, ist die Verwendung der Range-Methode für kleine Listen und - Aufzählungsmethode für Listen mittlerer und großer Größe.

Bitte sehen Sie sich verschiedene Ansätze an, mit denen Sie über Listen- und Zugriffsindexwerte iterieren und deren Leistungsmetriken (was ich für nützlich halte) in 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

Siehe Leistungsmetriken 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

Folglich ist die Verwendung der range -Methode die schnellste Methode, die mit 1000 Elementen aufgelistet werden kann. Bei einer Liste mit einer Größe> 10 000 Elementen ist enumerate der Gewinner.

Anbei einige nützliche Links:

18
Andriy Ivaneyko
ints = [9, 23, 45, 12, 78]
ints.extend([1,2,3,4,5,6,7,8])
for idx, val in enumerate(ints):
    print(idx,val)

Auf diese Weise können Sie eine Liste erweitern. Erweitern bedeutet, dass Sie mehrere Werte gleichzeitig hinzufügen können.

Um diese Liste anzufügen, müssen Sie den folgenden Code schreiben:

ints = [9, 23, 45, 12, 78]
ints.append([1])
for idx, val in enumerate(ints):
    print(idx,val)

Auf diese Weise können Sie jeweils einen einzelnen Wert hinzufügen. Wenn Sie ints.append([1]) schreiben, wird eine Unterliste für dieses Element erstellt.

15
iamjayp

Zunächst werden die Indizes von 0 bis 4 sein. Programmiersprachen beginnen mit 0 zu zählen; Vergiss das nicht oder du wirst auf einen Index außerhalb der Grenzen stoßen. In der for-Schleife brauchen Sie nur 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]
11
ytpillai

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
9
Liam

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 mit der alten Sprache oder mit 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/

9
thinker007

Die beste Lösung für dieses Problem ist die Verwendung der Python-Funktion enumerate in-build. 
Aufzählung return Tuple  
erster Wert ist index  
zweiter 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)
8
Anurag Misra

Wenn es keinen doppelten Wert in der Liste gibt:

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

Andernfalls verwenden Sie enumerate

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

ODER verwenden Sie unten:

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

Folgendes erhalten Sie, wenn Sie in for-Schleifen auf den Index zugreifen:

for i in enumerate(items): print(i)

 enter image description here

for i, val in enumerate(items): print(i, val)

 enter image description here

for i, val in enumerate(items): print(i)

 enter image description here

Hoffe das hilft.

4
ARGeo

In Ihrer Frage schreiben Sie "wie kann ich auf den Schleifenindex zugreifen, in diesem Fall von 1 bis 5?"

Der Index für eine Liste läuft jedoch von Null ab. Dann müssen wir wissen, ob Sie wirklich den Index und das Element für jedes Element in einer Liste wünschen oder ob Sie wirklich Zahlen ab 1 wünschen.

Um die Aufzählungsfunktion zu verdeutlichen, wird zunächst der Index und das entsprechende Element für jedes Element in einer Liste iterativ zurückgegeben.

alist = [ 1, 2, 3, 4, 5 ]

for n,a in enumerate(alist):
    print( "%d %d"%(n,a) )

Die Ausgabe für das Obige ist dann

0 1
1 2
2 3
3 4
4 5

Beachten Sie, dass der Index von 0 abläuft. Diese Art der Indexierung ist bei modernen Programmiersprachen wie Python und c üblich.

Wenn Ihre Schleife einen Teil der Liste umfassen soll, können Sie die Standard-Python-Syntax für einen Teil der Liste verwenden. Um beispielsweise vom zweiten Element in einer Liste bis zum letzten Element zu blättern, könnten Sie es verwenden

for n,a in enumerate(alist[1:-1]):
    print( "%d %d"%(n,a) )

Beachten Sie, dass der Ausgabeindex erneut von 0 abläuft.

0 2
1 3
2 4

Das bringt uns zum Start = n Schalter für Enumerate (). Dadurch wird der Index einfach versetzt, und Sie können dem Index innerhalb der Schleife äquivalent eine Zahl hinzufügen.

for n,a in enumerate(alist,start=1):
    print( "%d %d"%(n,a) )

für die die Ausgabe ist

1 1
2 2
3 3
4 4
5 5
3
DrM

Sie können dies auch versuchen:

data = ['itemA.ABC', 'itemB.defg', 'itemC.drug', 'itemD.ashok']
x = []
for (i, item) in enumerate(data):
      a = (i, str(item).split('.'))
      x.append(a)
for index, value in x:
     print(index, value)

Die Ausgabe ist 

0 ['itemA', 'ABC']
1 ['itemB', 'defg']
2 ['itemC', 'drug']
3 ['itemD', 'ashok']

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

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

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

for i in range(1, l + 1):
    print(i, nums[i])
2
Ankur Kothari

Sie können die index-Methode verwenden

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

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

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 möchten.

In der ausgewählten Antwort auf diese Frage wird die Methode enumerate verwendet, jedoch mit Listenverständnis, das mit weniger Code schneller geht.

1
PyRsquared

Um Tupel von (Index, Wert) im Listenverständnis mit einer for-Schleife auszudrucken:

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

Dies erfüllt den Zweck gut genug:

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

Dies kann auch mit der index()-Methode durchgeführt werden 

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

Hier beginnt die Indizierung bei 0. Wenn Sie jedoch von 1 aus beginnen müssen, fügen Sie einfach 1 zur index()-Methode hinzu

for i in int:
   print(int.index(i) + 1, i)    
0
Loochie