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




c# iterate (18)

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/

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?


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

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)

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.


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

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.


Dies ist gut genug:

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

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

Die Verwendung einer zusätzlichen Zustandsvariablen, z. B. einer Indexvariablen (die Sie normalerweise in Sprachen wie C oder PHP verwenden würden) gilt als nicht pythonisch.

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

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

PEP 279 enthält weitere Informationen .


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)

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

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

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 ist. 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 Variable 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 zum Halten des 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. zB mit itertools.chain für for. Es behandelt geschachtelte Schleifen besser als die anderen Beispiele.


In Ihrer Frage schreiben Sie "wie greife ich in diesem Fall von 1 bis 5 auf den Schleifenindex zu?"

Der Index für eine Liste läuft jedoch von Null ab. Wir müssen also 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. In Python ist es zum Glück einfach, beides oder beides zu tun.

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. 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

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

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:


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

As per the documentation provided by PHP manual.

On each iteration, the value of the current element is assigned to $v and the internal
array pointer is advanced by one (so on the next iteration, you'll be looking at the next element).

So as per your first example:

$array = ['foo'=>1];
foreach($array as $k=>&$v)
{
   $array['bar']=2;
   echo($v);
}

$array have only single element, so as per the foreach execution, 1 assign to $v and it don't have any other element to move pointer

But in your second example:

$array = ['foo'=>1, 'bar'=>2];
foreach($array as $k=>&$v)
{
   $array['baz']=3;
   echo($v);
}

$array have two element, so now $array evaluate the zero indices and move the pointer by one. For first iteration of loop, added $array['baz']=3; as pass by reference.







python loops list