Domanda Accedere all'indice in cicli 'for'?


Come posso accedere all'indice stesso per un elenco come il seguente?

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

Quando lo passo attraverso usando a for loop, come posso accedere all'indice del ciclo, da 1 a 5 in questo caso?


2559
2018-02-06 22:47


origine


risposte:


L'uso di una variabile di stato aggiuntiva, come una variabile di indice (che normalmente utilizzeresti in linguaggi come C o PHP), è considerata non-pitonica.

L'opzione migliore è usare la funzione built-in enumerate(), disponibile in entrambi Python 2 e 3:

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

Check-out PEP 279 per più.


4444
2018-02-06 22:52



Usando un ciclo for, come posso accedere all'indice del ciclo, da 1 a 5 in questo caso?

Uso enumerate per ottenere l'indice con l'elemento durante l'iterazione:

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

E nota che gli indici di Python partono da zero, quindi otterrai 0 a 4 con quanto sopra. Se vuoi il conteggio, da 1 a 5, fai questo:

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

Flusso di controllo unidiomatico

Quello che chiedi è l'equivalente Python di quanto segue, che è l'algoritmo utilizzato dalla maggior parte dei programmatori di linguaggi di livello inferiore:

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

O in lingue che non hanno un ciclo for-each:

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

o qualche volta più comunemente (ma unidiomaticamente) trovato in Python:

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

Utilizzare la funzione Enumerazione

Python enumerate funzione riduce il disordine visivo nascondendo la contabilità degli indici e incapsulando il iterabile in un altro iterabile (un enumerate oggetto) che produce una tupla di due elementi dell'indice e l'elemento che l'originale iterabile fornirebbe. Questo sembra:

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

Questo esempio di codice è abbastanza buono canonico esempio della differenza tra codice che è idiomatico di Python e codice che non lo è. Il codice idiomatico è sofisticato (ma non complicato) Python, scritto nel modo in cui era destinato ad essere usato. Il codice idiomatico è previsto dai progettisti del linguaggio, il che significa che di solito questo codice non è solo più leggibile, ma anche più efficiente.

Ottenere un conteggio

Anche se non hai bisogno degli indici mentre vai, ma hai bisogno di un conteggio delle iterazioni (a volte desiderabili) puoi iniziare con 1 e il numero finale sarà il tuo conteggio.

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

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

Il conteggio sembra essere più quello che intendi chiedere (al contrario dell'indice) quando hai detto che volevi dall'1 al 5.


Abbattendolo - una spiegazione passo passo

Per interrompere questi esempi, diciamo che abbiamo un elenco di elementi che vogliamo ripetere con un indice:

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

Ora passiamo questo iterabile per enumerare, creando un oggetto enumerare:

enumerate_object = enumerate(items) # the enumerate object

Possiamo estrarre il primo elemento da questo iterabile che avremmo ottenuto un ciclo con il next funzione:

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

E vediamo che otteniamo una tupla di 0, il primo indice, e 'a', il primo oggetto:

(0, 'a')

possiamo usare ciò che viene definito come "sequenza di spacchettamento"per estrarre gli elementi da questa due tupla:

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

e quando ispezioniamo index, troviamo che si riferisce al primo indice, 0 e item si riferisce al primo oggetto, 'a'.

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

Conclusione

  • Gli indici Python partono da zero
  • Per ottenere questi indici da un iterabile mentre si itera su di esso, utilizzare la funzione enumerate
  • L'uso dell'enumerazione in modo idiomatico (insieme alla tuple decompressione) crea un codice che è più leggibile e mantenibile:

Quindi fai questo:

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

516
2018-01-21 17:11



È piuttosto semplice da cui iniziare 1 diverso da 0:

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

Nota

Suggerimento importante, anche se un po 'fuorviante da allora index sarà un tuple  (idx, item) Qui. Buono per andare


105
2018-05-27 10:04



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

67
2018-02-06 22:49



Come è normale in Python ci sono diversi modi per farlo. In tutti gli esempi si assume: lst = [1, 2, 3, 4, 5]

1. Usando enumerare (considerato più idiomatico)

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

Questa è anche l'opzione più sicura a mio parere perché è stata eliminata la possibilità di andare in ricorsione infinita. Sia l'oggetto che l'indice sono contenuti in variabili e non è necessario scrivere alcun altro codice per accedere all'articolo.

2. Creazione di una variabile per contenere l'indice (utilizzando for)

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

3. Creazione di una variabile per contenere l'indice (utilizzando while)

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

4. C'è sempre un altro modo

Come spiegato in precedenza, ci sono altri modi per farlo che non sono stati spiegati qui e potrebbero anche applicarsi di più in altre situazioni. per esempio utilizzando itertools.chain con per. Gestisce i cicli annidati meglio degli altri esempi.


34
2017-08-15 02:17



Modo antiquato:

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

Comprensione delle liste:

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



Il modo più veloce per accedere agli indici della lista all'interno di loop in Python 2.7 è usare il metodo di intervallo per piccole liste e metodo di enumerazione per elenchi di dimensioni medie e enormi.

Perfavore guarda approcci diversi che può essere utilizzato per scorrere l'elenco e accedere al valore dell'indice e le loro metriche sul rendimento (che suppongo sarebbe utile per voi) nei seguenti esempi di codice:

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

Consulta le metriche sul rendimento per ciascun metodo riportato di seguito:

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

Come risultato, usando range il metodo è il più veloce fino alla lista con 1000 articoli. Per la lista con dimensioni> 10 000 articoli enumerate è il vincitore.

Aggiungendo alcuni link utili di seguito:


16
2017-08-04 09:49



Non so se il seguente è pythonic o no, ma usa la funzione Python enumerate e stampa l'indice e il valore.

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

Produzione:

0 8
1 23
2 45
3 12
4 78

16
2017-10-28 18:17