python dizionari - Accedere all'indice in cicli 'for'?




ciclo dizionario (18)

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?


Answers

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

1. Usare 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'elemento.

2. Creazione di una variabile per contenere l'indice ( usando 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. ad esempio utilizzando itertools.chain con for. Gestisce i cicli annidati meglio degli altri esempi.


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 Python 2 e 3:

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

Scopri PEP 279 per ulteriori informazioni.


Se non ci sono valori duplicati nell'elenco:

for i in ints:
        indx=ints.index(i)
        print(i,indx)

Invece usa enumerate.

for counter, value in enumerate(ints):
    print(counter, value)

O utilizzare di seguito:

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

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

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

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)

È 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


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

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

Nella tua domanda scrivi "come posso accedere all'indice del ciclo, da 1 a 5 in questo caso?"

Tuttavia, l'indice per un elenco, viene eseguito da zero. Quindi, allora abbiamo bisogno di sapere se ciò che realmente vuoi è l'indice e l'elemento per ogni elemento in una lista, o se vuoi davvero i numeri a partire da 1. Fortunatamente, in python è facile fare una o entrambe le cose.

Innanzitutto, per chiarire, la funzione enumerate restituisce in modo iterativo l'indice e l'elemento corrispondente per ciascun elemento in un elenco.

alist = [ 1, 2, 3, 4, 5 ]

for n,a in enumerate(alist):
    print( "%d %d"%(n,a) )

L'output per quanto sopra è quindi,

0 1
1 2
2 3
3 4
4 5

Si noti che l'indice viene eseguito da 0. Questo tipo di indicizzazione è comune tra i moderni linguaggi di programmazione tra cui python e c.

Se vuoi che il tuo loop si estenda su una parte dell'elenco, puoi usare la sintassi standard di python per una parte dell'elenco. Ad esempio, per eseguire il loop dal secondo elemento di un elenco fino a ma non incluso l'ultimo elemento, è possibile utilizzare

for n,a in enumerate(alist[1:-1]):
    print( "%d %d"%(n,a) )

Si noti che, ancora una volta, l'indice di output viene eseguito da 0,

0 2
1 3
2 4

Questo ci porta all'inizio = n switch per enumerate (). Questo semplicemente compensa l'indice, puoi semplicemente aggiungere un numero all'indice all'interno del ciclo.

for n,a in enumerate(alist,start=1):
    print( "%d %d"%(n,a) )

per cui l'output è

1 1
2 2
3 3
4 4
5 5

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

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

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)

In questo modo puoi estendere un elenco. Estendi significa che puoi aggiungere più valori alla volta.

Per aggiungere questo elenco devi scrivere il codice riportato di seguito:

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

In questo modo puoi aggiungere un singolo valore alla volta. Se scrivi ints.append([1]) , questo creerà un sottoelenco per questo elemento.


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

Prima di tutto, gli indici saranno da 0 a 4. I linguaggi di programmazione iniziano a contare da 0; non dimenticarlo o ti imbatterai in un indice fuori limite. Tutto ciò di cui hai bisogno nel ciclo for è un conteggio variabile da 0 a 4 in questo modo:

for x in range(0, 5):

Tieni presente che ho scritto da 0 a 5 perché il loop arresta un numero prima del massimo. :)

Utilizzare il valore di un indice

list[index]

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)

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

Trovare l'indice di un oggetto dato un elenco che lo contiene in Python

Per una lista ["foo", "bar", "baz"] e un elemento nella lista "bar" , qual è il modo più pulito per ottenere il suo indice (1) in Python?

Beh, certo, c'è il metodo index, che restituisce l'indice della prima occorrenza:

>>> l = ["foo", "bar", "baz"]
>>> l.index('bar')
1

Ci sono un paio di problemi con questo metodo:

  • se il valore non è nella lista, otterrai un ValueError
  • se più di uno dei valori è presente nell'elenco, ottieni solo l'indice per il primo

Nessun valore

Se il valore potrebbe essere mancante, è necessario rilevare l' ValueError .

Puoi farlo con una definizione riutilizzabile come questa:

def index(a_list, value):
    try:
        return a_list.index(value)
    except ValueError:
        return None

E usalo in questo modo:

>>> print(index(l, 'quux'))
None
>>> print(index(l, 'bar'))
1

E il lato negativo di questo è che probabilmente avrai un controllo per se il valore restituito is o is not None:

result = index(a_list, value)
if result is not None:
    do_something(result)

Più di un valore nell'elenco

Se potresti avere più occorrenze, non otterrai informazioni complete con list.index :

>>> l.append('bar')
>>> l
['foo', 'bar', 'baz', 'bar']
>>> l.index('bar')              # nothing at index 3?
1

Puoi enumerare in una lista la comprensione degli indici:

>>> [index for index, v in enumerate(l) if v == 'bar']
[1, 3]
>>> [index for index, v in enumerate(l) if v == 'boink']
[]

Se non si verificano occorrenze, è possibile verificarlo con il controllo booleano del risultato oppure non fare nulla se si esegue il loop dei risultati:

indexes = [index for index, v in enumerate(l) if v == 'boink']
for index in indexes:
    do_something(index)

Migliori dati munging con i panda

Se hai dei panda, puoi facilmente ottenere queste informazioni con un oggetto Series:

>>> import pandas as pd
>>> series = pd.Series(l)
>>> series
0    foo
1    bar
2    baz
3    bar
dtype: object

Un controllo di confronto restituirà una serie di booleani:

>>> series == 'bar'
0    False
1     True
2    False
3     True
dtype: bool

Passa quella serie di booleani alla serie tramite notazione degli iscritti e ottieni solo i membri corrispondenti:

>>> series[series == 'bar']
1    bar
3    bar
dtype: object

Se si desidera solo gli indici, l'attributo index restituisce una serie di numeri interi:

>>> series[series == 'bar'].index
Int64Index([1, 3], dtype='int64')

E se li vuoi in una lista o in una tupla, passali al costruttore:

>>> list(series[series == 'bar'].index)
[1, 3]

Sì, potresti usare anche una lista di enumerazione, ma non è altrettanto elegante, secondo me - stai facendo test per l'uguaglianza in Python, invece di lasciare che il codice incorporato scritto in C lo gestisca:

>>> [i for i, value in enumerate(l) if value == 'bar']
[1, 3]

È un problema XY ?

Il problema XY è chiedere la tua soluzione tentata piuttosto che il tuo problema reale.

Perché pensi di aver bisogno dell'indice dato un elemento in una lista?

Se conosci già il valore, perché ti importa dove si trova in una lista?

Se il valore non è lì, catturare l' ValueError è piuttosto prolisso - e preferisco evitarlo.

Di solito sto ripetendo l'elenco, quindi di solito manterrò un puntatore a qualsiasi informazione interessante, ottenendo l' indice con enumerazione.

Se stai mungendo i dati, probabilmente dovresti usare i panda - che ha strumenti molto più eleganti dei puri soluzioni alternative di Python che ho mostrato.

Non ricordo di aver bisogno di list.index , me stesso. Tuttavia, ho guardato attraverso la libreria standard di Python, e vedo alcuni usi eccellenti per questo.

Ci sono molti, molti usi per esso in idlelib , per la GUI e l'analisi del testo.

Il modulo di keyword lo usa per trovare marcatori di commenti nel modulo per rigenerare automaticamente l'elenco di parole chiave in esso tramite metaprogrammazione.

In Lib / mailbox.py sembra utilizzarlo come una mappatura ordinata:

key_list[key_list.index(old)] = new

e

del key_list[key_list.index(key)]

In Lib / http / cookiejar.py, sembra essere usato per ottenere il mese successivo:

mon = MONTHS_LOWER.index(mon.lower())+1

In Lib / tarfile.py simile alle distutils per ottenere una fetta fino a un oggetto:

members = members[:members.index(tarinfo)]

In Lib / pickletools.py:

numtopop = before.index(markobject)

Ciò che questi usi sembrano avere in comune è che sembrano operare su elenchi di dimensioni vincolate (importanti a causa del tempo di ricerca O (n) per list.index ), e sono principalmente utilizzati nell'analisi (e nell'interfaccia utente nel caso di Inattivo).

Mentre ci sono casi d'uso per questo, sono abbastanza rari. Se ti trovi alla ricerca di questa risposta, chiediti se quello che stai facendo è l'uso più diretto degli strumenti forniti dalla lingua per il tuo caso d'uso.





python loops list