Vraag Toegang tot de index in 'voor' loops?


Hoe krijg ik toegang tot de index zelf voor een lijst zoals de volgende?

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

Wanneer ik er doorheen loop met een for loop, hoe krijg ik toegang tot de loop-index, van 1 tot 5 in dit geval?


2560
2018-02-06 22:47


oorsprong


antwoorden:


Het gebruik van een extra toestandsvariabele, zoals een indexvariabele (die u normaal zou gebruiken in talen zoals C of PHP), wordt als niet-pythonisch beschouwd.

De betere optie is om de ingebouwde functie te gebruiken enumerate(), beschikbaar in zowel Python 2 als 3:

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

Uitchecken PEP 279 voor meer.


4444
2018-02-06 22:52



Hoe gebruik ik in een for-lus de lusindex, van 1 tot 5 in dit geval?

Gebruik enumerate om de index met het element te krijgen zoals u het opnieuw invoert:

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

En merk op dat de Pythons-indexen bij nul beginnen, dus je krijgt 0 tot 4 met het bovenstaande. Als je de telling wilt, 1 tot 5, doe dit:

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

Unidiomatische controlestroom

Waar u om vraagt ​​is het Pythonic equivalent van het volgende, wat het algoritme is dat de meeste programmeurs van talen van een lager niveau zullen gebruiken:

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

Of in talen die geen for-each-lus hebben:

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

of soms vaker (maar unidiomatisch) gevonden in Python:

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

Gebruik de functie Enumerate

Python's enumerate functie vermindert de visuele rommel door de boekhouding voor de indexen te verbergen en de iterabele in een andere iterabele (een enumerate object) dat een tweepunttuple van de index oplevert en het item dat het oorspronkelijke iterabele zou bieden. Dat ziet er zo uit:

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

Dit codevoorbeeld is redelijk goed de kanoniek voorbeeld van het verschil tussen code die idioom is voor Python en code die dat niet is. Idiomatische code is geavanceerd (maar niet gecompliceerd) Python, geschreven zoals het bedoeld was. Idiomatische code wordt verwacht door de ontwerpers van de taal, wat betekent dat deze code meestal niet alleen leesbaarder, maar ook efficiënter is.

Een telling krijgen

Zelfs als je geen indexen nodig hebt, maar je hebt een telling nodig van de iteraties (soms wenselijk), kun je beginnen met 1 en het definitieve aantal zal jouw telling zijn.

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

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

De telling lijkt meer te zijn wat u van plan bent te vragen (in tegenstelling tot index) toen u zei dat u van 1 tot 5 wilde.


Het doorbreken - een stap voor stap uitleg

Om deze voorbeelden te verbreken, stellen we dat we een lijst hebben met items die we willen herhalen met een index:

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

Nu geven we dit iterable door om een ​​opsomming te krijgen van, en een op te sommen object te maken:

enumerate_object = enumerate(items) # the enumerate object

We kunnen het eerste item uit dit iterable halen dat we in een lus zouden komen met de next functie:

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

En we zien dat we er een tuple van krijgen 0, de eerste index, en 'a', het eerste item:

(0, 'a')

we kunnen gebruiken wat wordt aangeduid als "sequentie uitpakken"om de elementen uit deze two-tuple te halen:

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

en wanneer we inspecteren index, we vinden dat het verwijst naar de eerste index, 0, en item verwijst naar het eerste item, 'a'.

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

Conclusie

  • Python-indexen beginnen bij nul
  • Als u deze indexen van een iterabele wilt ophalen terwijl u deze itereert, gebruikt u de functie enumerate
  • Met behulp van enumerate op de idiomatische manier (samen met tuple uitpakken) creëert code die leesbaarder en onderhoudbaarder is:

Dus doe dit:

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

516
2018-01-21 17:11



Het is vrij eenvoudig om het te starten 1 anders dan 0:

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

Notitie

Belangrijke tip, hoewel een beetje misleidend sindsdien index zal een ... zijn tuple  (idx, item) hier. Klaar om te vertrekken.


105
2018-05-27 10:04



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

67
2018-02-06 22:49



Zoals de norm in Python is, zijn er verschillende manieren om dit te doen. Ga in alle voorbeelden ervan uit: lst = [1, 2, 3, 4, 5]

1. Gebruiken enumerate (beschouwd als de meest idiomatische)

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

Dit is naar mijn mening ook de veiligste optie omdat de kans op een oneindige recursie is geëlimineerd. Zowel het artikel als de index worden in variabelen vastgehouden en het is niet nodig om nog meer code te schrijven om toegang te krijgen tot het item.

2. Een variabele maken om de index te houden (gebruik makend van for)

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

3. Een variabele maken om de index te houden (gebruik makend van while)

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

4. Er is altijd een andere manier

Zoals eerder uitgelegd, zijn er andere manieren om dit te doen, die hier niet zijn uitgelegd en ze kunnen zelfs meer toepassen in andere situaties. bv gebruik makend van itertools.chain met voor. Het verwerkt geneste lussen beter dan de andere voorbeelden.


34
2017-08-15 02:17



Ouderwetse manier:

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

Begrip van de lijst:

[ (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



De snelste manier om toegang te krijgen tot de indexen van de lijst binnen de lus Python 2.7 is om de bereik methode voor kleine lijsten en enumerate methode voor middelgrote en grote lijsten.

Alsjeblieft zie verschillende benaderingen die kan worden gebruikt om de lijst te herhalen en toegang te krijgen tot de indexwaarde en hun prestatiestatistieken (waarvan ik veronderstel dat het nuttig voor je is) in onderstaande codevoorbeelden:

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

Bekijk prestatiestatistieken voor elke onderstaande methode:

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 gevolg hiervan range methode is de snelste die op de lijst staat met 1000 items. Voor een lijst met een grootte> 10 000 items enumerate is de winnaar.

Hieronder enkele handige links:


16
2017-08-04 09:49



Ik weet niet of het volgende pythonic is of niet, maar het gebruikt de Python-functie enumerate en drukt de index en de waarde af.

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

Output:

0 8
1 23
2 45
3 12
4 78

16
2017-10-28 18:17



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)

Op deze manier kunt u een lijst uitbreiden. Uitbreiden betekent dat je meerdere waarden tegelijk kunt toevoegen.

Om deze lijst toe te voegen moet je de onderstaande code schrijven:

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

Op deze manier kunt u één waarde per keer toevoegen. Als je schrijft ints.append([1]) dus dit maakt een sublijst voor dit element.


15
2018-02-05 17:28



Allereerst zullen de indexen 0 tot 4 zijn. Programmeertalen beginnen met tellen vanaf 0; vergeet dat niet, anders kom je een uitzondering buiten de grenzen tegen. Alles wat je nodig hebt in de for-lus is een variabele van 0 tot 4, zoals zo:

for x in range(0, 5):

Houd in gedachten dat ik 0 tot 5 schreef omdat de lus één getal vóór de max stopt. :)

Om de waarde van een index te gebruiken

list[index]

11
2018-05-25 15:08