Hoe krijg ik toegang tot de index in een for-lus zoals de volgende?
ints = [8, 23, 45, 12, 78]
for i in ints:
print('item #{} = {}'.format(???, i))
Ik wil deze uitvoer krijgen:
item #1 = 8
item #2 = 23
item #3 = 45
item #4 = 12
item #5 = 78
Als ik er doorheen loop met een forlus, hoe krijg ik dan toegang tot de lusindex, in dit geval van 1 tot 5?
Antwoord 1, autoriteit 100%
Het gebruik van een extra statusvariabele, zoals een indexvariabele (die u normaal gesproken 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)
Bekijk PEP 279voor meer informatie.
Antwoord 2, autoriteit 13%
Hoe krijg ik met een for-lus toegang tot de loop-index, in dit geval van 1 tot 5?
Gebruik enumerateom de index met het element te krijgen terwijl je itereert:
for index, item in enumerate(items):
print(index, item)
En merk op dat de indexen van Python beginnen bij nul, dus je zou 0 tot 4 krijgen met het bovenstaande. Als je de telling wilt, van 1 tot 5, doe dit:
for count, item in enumerate(items, start=1):
print(count, item)
Unidiomatische besturingsstroom
Wat u vraagt is het Pythonische equivalent van het volgende, het algoritme dat de meeste programmeurs van lagere talen zouden 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 Opsomming
Python’s enumerate-functievermindert de visuele rommel door de boekhouding voor de indexen te verbergen en de iterabele in te kapselen in een ander iterabel (een enumerateobject) dat een tuple van twee items van de index oplevert en het item dat de originele iterable 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 canoniekvoorbeeld van het verschil tussen code die idiomatisch is voor Python en code die dat niet is. Idiomatische code is geavanceerde (maar niet gecompliceerde) Python, geschreven op de manier waarop het bedoeld was om te worden gebruikt. 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 onderweg geen indexen nodig hebt, maar wel een telling van de iteraties nodig hebt (soms wenselijk), kun je beginnen met 1en het uiteindelijke aantal zal je telling zijn.
p>
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 opsplitsen – een stapsgewijze uitleg
Om deze voorbeelden op te splitsen, stel dat we een lijst hebben met items die we willen herhalen met een index:
items = ['a', 'b', 'c', 'd', 'e']
Nu geven we deze iterable door aan enumerate, waardoor een enumerate object wordt gemaakt:
enumerate_object = enumerate(items) # the enumerate object
We kunnen het eerste item uit deze iterable halen dat we in een lus zouden krijgen met de functie next:
iteration = next(enumerate_object) # first iteration from enumerate
print(iteration)
En we zien dat we een tuple krijgen van 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 twee-tupel te extraheren:
index, item = iteration
# 0, 'a' = (0, 'a') # essentially this.
en als we indexinspecteren, zien we dat het verwijst naar de eerste index, 0, en itemverwijst naar het eerste item, 'a'.
>>> print(index)
0
>>> print(item)
a
Conclusie
- Python-indexen beginnen bij nul
- Gebruik de enumerate-functie om deze indexen uit een iterabel te halen terwijl u eroverheen itereert
- Het gebruik van enumerate op de idiomatische manier (samen met tuple unpacking) creëert code die beter leesbaar en onderhoudbaar is:
Dus doe dit:
for index, item in enumerate(items, start=0): # Python indexes start at zero
print(index, item)
Antwoord 3, autoriteit 3%
Het is vrij eenvoudig om het te starten vanaf 1anders dan 0:
for index, item in enumerate(iterable, start=1):
print index, item # Used to print in python<3.x
print(index, item) # Mirate print() after 3.x+
Antwoord 4
for i in range(len(ints)):
print(i, ints[i]) # print updated to print() in Python 3.x+
Antwoord 5
Zoals de norm in Python zijn er verschillende manieren om dit te doen. In alle voorbeelden veronderstellen: lst = [1, 2, 3, 4, 5]
1. Met behulp van opsommen (beschouwd als de meest idiomatische )
for index, element in enumerate(lst):
# do the things that need doing here
Dit is ook de veiligste optie naar mijn mening omdat de kans om in oneindige recursie te gaan is geëlimineerd. Zowel het item als de index worden in variabelen gehouden en het is niet nodig om meer code te schrijven
om toegang te krijgen tot het item.
2. Een variabele maken om de index (te houden met 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 met 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 in andere situaties toepassen. E.G met itertools.chainmet voor. Het behandelt geneste lussen beter dan de andere voorbeelden.
Antwoord 6
ouderwetse manier:
for ix in range(len(ints)):
print(ints[ix])
Lijstbegrip:
[ (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)
>>>
Antwoord 7
Toegang tot indexen & amp; Performance benchmarking van benaderingen
De snelste manier om toegang te krijgen tot indexen van lijst binnen lus in python 3.7 is om de Opsommende methode voor kleine, middelgrote en grote lijsten.
Zie verschillende benaderingen die kunnen worden gebruikt om te herhalen boven de lijst en toegang indexwaarde en hun prestatiemeters (die denkt dat ik nuttig voor u zou zijn) in codemonsters hieronder:
# Using range
def range_loop(iterable):
for i in range(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
Zie 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("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 speed for list with 1000 items
measure(range(1000))
# range: 1.161622366
# enumerate: 0.5661940879999996
# manual_indexing: 0.610455682
# Measure speed for list with 100000 items
measure(range(10000))
# range: 11.794482958
# enumerate: 6.197628574000001
# manual_indexing: 6.935181098000001
# Measure speed for list with 10000000 items
measure(range(10000000), number=100)
# range: 121.416859069
# enumerate: 62.718909123
# manual_indexing: 69.59575057400002
Als resultaat is het gebruik van de enumerate-methode de snelste methode voor iteratie wanneer de index dat nodig heeft.
Een aantal handige links hieronder toevoegen:
-
Wat is het verschil tussen range- en xrange-functies in Python 2.X?
-
Wat is sneller for loop met enumerate of for loop met xrange in Python?
Antwoord 8
Dit is wat je krijgt als je de index opent in forloops:
for i in enumerate(items): print(i)
items = [8, 23, 45, 12, 78]
for i in enumerate(items):
print("index/value", i)
Resultaat:
# index/value (0, 8)
# index/value (1, 23)
# index/value (2, 45)
# index/value (3, 12)
# index/value (4, 78)
for i, val in enumerate(items): print(i, val)
items = [8, 23, 45, 12, 78]
for i, val in enumerate(items):
print("index", i, "for value", val)
Resultaat:
# index 0 for value 8
# index 1 for value 23
# index 2 for value 45
# index 3 for value 12
# index 4 for value 78
for i, val in enumerate(items): print(i)
items = [8, 23, 45, 12, 78]
for i, val in enumerate(items):
print("index", i)
Resultaat:
# index 0
# index 1
# index 2
# index 3
# index 4
Antwoord 9
Allereerst zullen de indexen van 0 tot 4 zijn. Programmeertalen beginnen te tellen vanaf 0; vergeet dat niet, anders kom je een index-out-of-bounds-uitzondering tegen. Alles wat je nodig hebt in de for-lus is een variabele die van 0 tot 4 telt, zoals:
for x in range(0, 5):
Houd er rekening mee dat ik 0 tot 5 heb geschreven omdat de lus één cijfer voor de max stopt. 🙂
Gebruik om de waarde van een index te krijgen
list[index]
Antwoord 10
Volgens deze discussie: http://bytes.com/topic /python/answers/464012-objects-list-index
Loop counter iteratie
Het huidige idioom voor het doorlopen van de indices maakt gebruik van de ingebouwde range-functie:
for i in range(len(sequence)):
# work with index i
Het herhalen van zowel elementen als indexen kan worden bereikt met het oude idioom of door de nieuwe ingebouwde functie zipte gebruiken:
for i in range(len(sequence)):
e = sequence[i]
# work with index i and element e
of
for i, e in zip(range(len(sequence)), sequence):
# work with index i and element e
via http://www.python.org/dev/peps/pep- 0212/
Antwoord 11
Je kunt het doen met deze code:
ints = [8, 23, 45, 12, 78]
index = 0
for value in (ints):
index +=1
print index, value
Gebruik deze code als u de indexwaarde aan het einde van de lus moet resetten:
ints = [8, 23, 45, 12, 78]
index = 0
for value in (ints):
index +=1
print index, value
if index >= len(ints)-1:
index = 0
Antwoord 12
Als ik nums = [1, 2, 3, 4, 5]zou herhalen, zou ik dat doen
for i, num in enumerate(nums, start=1):
print(i, num)
of krijg de lengte als l = len(nums)
for i in range(l):
print(i+1, nums[i])
Antwoord 13
De beste oplossing voor dit probleem is om de enumeratete gebruiken.
enumerateRetourneert een tuple, waarbij de eerste waarde de index is en de tweede waarde is het element van de lijst bij die 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)
Antwoord 14
In uw vraag schrijft u “Hoe krijg ik toegang tot de lusindex, van 1 tot 5 in dit geval?”
De index voor een lijst loopt echter van nul. Dus, dan moeten we weten of wat u daadwerkelijk wilt is de index en het item voor elk item in een lijst, of of u echt nummers wilt beginnen met 1. Gelukkig, in Python, is het gemakkelijk om of beide te doen.
Eerste, om te verduidelijken, de enumerate-functie retourneert het index en het bijbehorende item voor elk item in een lijst.
alist = [1, 2, 3, 4, 5]
for n, a in enumerate(alist):
print("%d %d" % (n, a))
De uitvoer voor het bovenstaande is dan,
0 1
1 2
2 3
3 4
4 5
Merk op dat de index van 0. Dit soort indexering komt vaak voor bij moderne programmeertalen, waaronder Python en c.
Als u wilt dat uw lus een deel van de lijst beslaat, kunt u de standaard Python-syntaxis voor een deel van de lijst gebruiken. Als u bijvoorbeeld wilt doorlopen van het tweede item in een lijst tot maar niet met het laatste item, kunt u
. gebruiken
for n, a in enumerate(alist[1:-1]):
print("%d %d" % (n, a))
Merk op dat nogmaals, de uitvoerindex loopt van 0,
0 2
1 3
2 4
Dat brengt ons bij de schakeloptie start=nvoor enumerate(). Dit compenseert eenvoudig de index, u kunt op dezelfde manier eenvoudig een nummer toevoegen aan de index in de lus.
for n, a in enumerate(alist, start=1):
print("%d %d" % (n, a))
waarvoor de uitvoer is
1 1
2 2
3 3
4 4
5 5
Antwoord 15
Je kunt ook dit proberen:
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)
De uitvoer is
0 ['itemA', 'ABC']
1 ['itemB', 'defg']
2 ['itemC', 'drug']
3 ['itemD', 'ashok']
Antwoord 16
Als er geen dubbele waarde in de lijst staat:
for i in ints:
indx = ints.index(i)
print(i, indx)
Antwoord 17
U kunt de indexmethode
. gebruiken
ints = [8, 23, 45, 12, 78]
inds = [ints.index(i) for i in ints]
bewerken
Gemarkeerd in de opmerking dat deze methode niet werkt als er duplicaten zijn in ints, moet de onderstaande methode werken voor alle waarden in ints:
ints = [8, 8, 8, 23, 45, 12, 78]
inds = [tup[0] for tup in enumerate(ints)]
of als alternatief
ints = [8, 8, 8, 23, 45, 12, 78]
inds = [tup for tup in enumerate(ints)]
Als u zowel de index als de waarde in intsals een lijst met tuples wilt krijgen.
Het gebruikt de methode van enumeratein het geselecteerde antwoord op deze vraag, maar met vermelding van het lijst, waardoor het sneller wordt met minder code.
Antwoord 18
Eenvoudig antwoord met behulp van terwijl Loop:
arr = [8, 23, 45, 12, 78]
i = 0
while i < len(arr):
print("Item ", i + 1, " = ", arr[i])
i += 1
Uitgang:
Antwoord 19
Om tuple van (index, waarde) af te drukken in het begrip van de lijst met behulp van een forlus:
ints = [8, 23, 45, 12, 78]
print [(i,ints[i]) for i in range(len(ints))]
Uitgang:
[(0, 8), (1, 23), (2, 45), (3, 12), (4, 78)]
Antwoord 20
Dit dient het doel goed genoeg:
list1 = [10, 'sumit', 43.21, 'kumar', '43', 'test', 3]
for x in list1:
print('index:', list1.index(x), 'value:', x)
Antwoord 21
U kunt eenvoudig een variabele zoals countgebruiken om het aantal elementen in de lijst te tellen:
ints = [8, 23, 45, 12, 78]
count = 0
for i in ints:
count = count + 1
print('item #{} = {}'.format(count, i))
Antwoord 22
Je kunt enumerate gebruiken om de lijst te doorlopen en start=1gebruiken omdat het standaard op 0 staat, wat betekent dat het bij 0 begint te tellen.
Hier is een voorbeeld:
for index,val in enumerate(ints,start=1):
print(f"item #{index} = {val}")
Het gebruik van f-stringsis ook een snelle manier om uw gevraagde uitvoer te krijgen en het is beter leesbaar omdat u index en val direct in {}-placeholder kunt doorgeven.
Uitvoer:
item #1 = 8
item #2 = 23
item #3 = 45
item #4 = 12
item #5 = 78
Antwoord 23
Gebruik enumerate om de lijst te doorlopen
ints = [8, 23, 45, 12, 78]
for idx,val in enumerate(ints):
print('item #{} = {}'.format(idx+1, val))
Uitvoer:
item #1 = 8
item #2 = 23
item #3 = 45
item #4 = 12
item #5 = 78