ordinare - unire dizionari python




Accedere all'indice in cicli 'for'? (14)

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

Usa 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

La funzione di enumerate di Python riduce il disordine visivo nascondendo la contabilità per gli indici e incapsulando l'iterabile in un altro iterabile (un oggetto enumerate ) 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 bene l'esempio canonical 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 di 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 la funzione next :

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 elemento:

(0, 'a')

possiamo usare quello che viene chiamato " decompressione della sequenza " per estrarre gli elementi da questa doppia tupla:

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

e quando ispezioniamo l' index , troviamo che si riferisce al primo indice, 0, e l' item riferisce al primo elemento, '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)

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

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

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


È abbastanza semplice avviarlo da 1 diverso da 0 :

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

Nota

Suggerimento importante, anche se un po 'fuorviante dal momento che l' index sarà una tuple (idx, item) qui. Buono per andare


Hai ricevuto un certo numero di risposte che spiegano enumerate , ma se hai solo bisogno dell'indice per accedere alle voci corrispondenti in due elenchi, c'è un altro modo più semplice e pulito in Python 3: zip .

Ad esempio, se stai utilizzando l'indice per estrarre i nomi corrispondenti per i numeri nel tuo elenco, puoi farlo in questo modo:

ints = [8, 23, 45, 12, 78]
names = ["John", "Sue", "Johannes", "Patel", "Ian"]
for int, name = zip(ints, names):
    print("{} - {}".format(name, int)

Ciò produrrebbe

8 - John
23 - Sue
45 - Johannes
12 - Patel
78 - Ian

Il modo più rapido per accedere agli indici della lista all'interno di loop in Python 2.7 è utilizzare il metodo range per le liste di piccole dimensioni e il metodo di enumerazione per elenchi di medie e grandi dimensioni.

Si prega di vedere diversi approcci che possono essere utilizzati per iterare sulla lista e accedere al valore dell'indice e alle 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, utilizzando il metodo range è il più veloce fino a elencare con 1000 articoli. Per la lista con dimensioni> 10.000 elementi enumerate è il vincitore.

Aggiungendo alcuni link utili di seguito:


La migliore soluzione per questo problema è usare enumerare la funzione python in-build.
enumerare la tupla di ritorno
il primo valore è indice
il secondo valore è l' elemento dell'array in quell'indice

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)

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

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

Per stampare tuple di (indice, valore) nella comprensione delle liste usando un ciclo for :

ints = [8, 23, 45, 12, 78]
print [(i,ints[i]) for i in range(len(ints))]

Produzione:

[(0, 8), (1, 23), (2, 45), (3, 12), (4, 78)]

Puoi anche provare questo:

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)

L'output è

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

Puoi farlo con questo codice:

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

for value in (ints):
    index +=1
    print index, value

Utilizzare questo codice se è necessario ripristinare il valore dell'indice alla fine del ciclo:

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

for value in (ints):
    index +=1
    print index, value
    if index >= len(ints)-1:
        index = 0

Questo serve allo scopo abbastanza bene:

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

Se dovessi iterare nums = [1,2,3,4,5], lo farei

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

Oppure ottieni la lunghezza come l = len (nums)

for i, num in range(1, l + 1):
    print(i, nums[i])

Secondo questa discussione: http://bytes.com/topic/python/answers/464012-objects-list-index

Iterazione del contatore di loop

L'attuale idioma per il looping sugli indici fa uso della funzione 'range' integrata:

for i in range(len(sequence)):
    # work with index i

Il loop su entrambi gli elementi e gli indici può essere ottenuto sia con il vecchio idioma sia usando la nuova funzione integrata "zip" [2]:

for i in range(len(sequence)):
    e = sequence[i]
    # work with index i and element e

o

for i, e in zip(range(len(sequence)), sequence):
    # work with index i and element e

tramite http://www.python.org/dev/peps/pep-0212/


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




list