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




elementi lista (23)

Per una lista ["foo", "bar", "baz"] e un elemento nella lista "bar" , come faccio a ottenere il suo indice (1) in Python?


Answers

Tutti gli indici con la funzione zip :

get_indexes = lambda x, xs: [i for (y, i) in zip(xs, range(len(xs))) if x == y]

print get_indexes(2, [1, 2, 3, 4, 5, 6, 3, 2, 3, 2])
print get_indexes('f', 'xsfhhttytffsafweef')

Tutte le funzioni proposte qui riproducono il comportamento inerente del linguaggio ma oscurano ciò che sta accadendo.

[i for i in range(len(mylist)) if mylist[i]==myterm]  # get the indices

[each for each in mylist if each==myterm]             # get the items

mylist.index(myterm) if myterm in mylist else None    # get the first index and fail quietly

Perché scrivere una funzione con gestione delle eccezioni se la lingua fornisce i metodi per fare ciò che si desidera da sé?


Semplicemente puoi andare con

a = [['hand', 'head'], ['phone', 'wallet'], ['lost', 'stock']]
b = ['phone', 'lost']

res = [[x[0] for x in a].index(y) for y in b]

Per ottenere tutti gli indici:

 indexes = [i for i,x in enumerate(xs) if x == 'foo']

Ci sono due possibilità se l'elenco non contiene elementi ripetuti per i quali è necessario controllare l'indice

 eg: li=[10,20,30] # here need to get index of 20 means
     li.index(20) # will work properly because 20 is not repeated

se è ripetuto significa che ti darà solo il primo indice

Se hai bisogno di ottenere tutto l'indice in cui è presente l'elemento significa

eg: li=[10,20,30,20,40, 50, 10] # here need to get index of 20 means its have 2 index (1,3) 

per ottenere quello che devi fare come

 li=[10,20,30,20,40, 50, 10]
 [i for i, e in enumerate(li) if e == 20]

allora otterrai una lista di indice come / p come [1,3]


Una cosa che è molto utile nell'apprendimento di Python è l'uso della funzione di guida interattiva:

>>> help(["foo", "bar", "baz"])
Help on list object:

class list(object)
 ...

 |
 |  index(...)
 |      L.index(value, [start, [stop]]) -> integer -- return first index of value
 |

che ti condurrà spesso al metodo che stai cercando.


C'è una risposta più funzionale a questo.

list(filter(lambda x: x[1]=="bar",enumerate(["foo", "bar", "baz", "bar", "baz", "bar", "a", "b", "c"])))

Forma più generica:

def get_index_of(lst, element):
    return list(map(lambda x: x[0],\
       (list(filter(lambda x: x[1]==element, enumerate(lst))))))

name ="bar"
list = [["foo", 1], ["bar", 2], ["baz", 3]]
new_list=[]
for item in list:
    new_list.append(item[0])
print(new_list)
try:
    location= new_list.index(name)
except:
    location=-1
print (location)

Questo spiega se la stringa non è presente nella lista, se non è nella lista allora location = -1


Se vuoi tutti gli indici, allora puoi usare NumPy :

import numpy as np

array = [1, 2, 1, 3, 4, 5, 1]
item = 1
np_array = np.array(array)
item_index = np.where(np_array==item)
print item_index
# Out: (array([0, 2, 6], dtype=int64),)

È una soluzione chiara e leggibile.


Per quelli che provengono da un'altra lingua come me, magari con un semplice ciclo, è più facile da capire e usarlo:

mylist = ["foo", "bar", "baz", "bar"]
newlist = enumerate(mylist)
for index, item in newlist:
  if item == "bar":
    print(index, item)

Sono grato per che cosa fa esattamente l'enumerazione? . Questo mi ha aiutato a capire.


Un problema si presenterà se l'elemento non è nella lista. Questa funzione gestisce il problema:

# if element is found it returns index of element else returns None

def find_element_in_list(element, list_element):
    try:
        index_element = list_element.index(element)
        return index_element
    except ValueError:
        return None

Questa soluzione non è potente come altri, ma se sei un principiante e conosci solo i loop è ancora possibile trovare il primo indice di un oggetto evitando l'errore ValueError:

def find_element(p,t):
    i = 0
    for e in p:
        if e == t:
            return i
        else:
            i +=1
    return -1

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.


index() restituisce il primo indice di valore!

| indice(...)
| L.index (value, [start, [stop]]) -> intero - restituisce il primo indice di valore

def all_indices(value, qlist):
    indices = []
    idx = -1
    while True:
        try:
            idx = qlist.index(value, idx+1)
            indices.append(idx)
        except ValueError:
            break
    return indices

all_indices("foo", ["foo","bar","baz","foo"])

a = ["foo","bar","baz",'bar','any','much']

indexes = [index for index in range(len(a)) if a[index] == 'bar']

Trovare l'indice dell'articolo x nell'elenco L :

idx = L.index(x) if (x in L) else -1

Il metodo python index() genera un errore se l'oggetto non è stato trovato, il che fa schifo!

Quindi, invece, puoi renderlo simile alla funzione indexOf() di JavaScript che restituisce -1 se l'elemento non è stato trovato:

    try:
        index = array.index('search_keyword')
    except ValueError:
        index = -1

Un'altra opzione

>>> a = ['red', 'blue', 'green', 'red']
>>> b = 'red'
>>> offset = 0;
>>> indices = list()
>>> for i in range(a.count(b)):
...     indices.append(a.index(b,offset))
...     offset = indices[-1]+1
... 
>>> indices
[0, 3]
>>> 

Come indicato da @TerryA, molte risposte discutono su come trovare un indice.

more_itertools è una libreria di terze parti con strumenti per individuare più indici all'interno di un iterabile.

Dato

import more_itertools as mit


iterable = ["foo", "bar", "baz", "ham", "foo", "bar", "baz"]

Codice

Trova indici di più osservazioni:

list(mit.locate(iterable, lambda x: x == "bar"))
# [1, 5]

Prova più oggetti:

list(mit.locate(iterable, lambda x: x in {"bar", "ham"}))
# [1, 3, 5]

Vedi anche altre opzioni con more_itertools.locate . Installa tramite more_itertools .


Devi impostare una condizione per verificare se l'elemento che stai cercando è nell'elenco

if 'your_element' in mylist:
    print mylist.index('your_element')
else:
    print None

Ottenere tutte le occorrenze e la posizione di uno o più oggetti (identici) in un elenco

Con enumerate (alist) è possibile memorizzare il primo elemento (n) che è l'indice della lista quando l'elemento x è uguale a quello che si cerca.

>>> alist = ['foo', 'spam', 'egg', 'foo']
>>> foo_indexes = [n for n,x in enumerate(alist) if x=='foo']
>>> foo_indexes
[0, 3]
>>>

Facciamo la nostra funzione findindex

Questa funzione prende l'articolo e l'elenco come argomenti e restituisce la posizione dell'elemento nell'elenco, come abbiamo visto prima.

def indexlist(item2find, list_or_string):
  "Returns all indexes of an item in a list or a string"
  return [n for n,item in enumerate(list_or_string) if item==item2find]

print(indexlist("1", "010101010"))

Produzione

[1, 3, 5, 7]

Semplice

for n, i in enumerate([1, 2, 3, 4, 1]):
    if i == 1:
        print(n)

Produzione:

0
4

E ora qualcosa di completamente diverso...

... come confermare l'esistenza dell'oggetto prima di ottenere l'indice. La cosa bella di questo approccio è che la funzione restituisce sempre un elenco di indici, anche se è una lista vuota. Funziona anche con le stringhe.

def indices(l, val):
    """Always returns a list containing the indices of val in the_list"""
    retval = []
    last = 0
    while val in l[last:]:
            i = l[last:].index(val)
            retval.append(last + i)
            last += i + 1   
    return retval

l = ['bar','foo','bar','baz','bar','bar']
q = 'bar'
print indices(l,q)
print indices(l,'bat')
print indices('abcdaababb','a')

Quando incollato in una finestra python interattiva:

Python 2.7.6 (v2.7.6:3a1db0d2747e, Nov 10 2013, 00:42:54) 
[GCC 4.2.1 (Apple Inc. build 5666) (dot 3)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> def indices(the_list, val):
...     """Always returns a list containing the indices of val in the_list"""
...     retval = []
...     last = 0
...     while val in the_list[last:]:
...             i = the_list[last:].index(val)
...             retval.append(last + i)
...             last += i + 1   
...     return retval
... 
>>> l = ['bar','foo','bar','baz','bar','bar']
>>> q = 'bar'
>>> print indices(l,q)
[0, 2, 4, 5]
>>> print indices(l,'bat')
[]
>>> print indices('abcdaababb','a')
[0, 4, 5, 7]
>>> 

Aggiornare

Dopo un altro anno di sviluppo di python a testa in giù, sono un po 'imbarazzato dalla mia risposta originale, quindi per impostare le cose in chiaro, si può certamente usare il codice di cui sopra; tuttavia, il modo molto più idiomatico per ottenere lo stesso comportamento sarebbe quello di utilizzare la comprensione delle liste, insieme alla funzione enumerate ().

Qualcosa come questo:

def indices(l, val):
    """Always returns a list containing the indices of val in the_list"""
    return [index for index, value in enumerate(l) if value == val]

l = ['bar','foo','bar','baz','bar','bar']
q = 'bar'
print indices(l,q)
print indices(l,'bat')
print indices('abcdaababb','a')

Il che, incollato in una finestra python interattiva, produce:

Python 2.7.14 |Anaconda, Inc.| (default, Dec  7 2017, 11:07:58) 
[GCC 4.2.1 Compatible Clang 4.0.1 (tags/RELEASE_401/final)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> def indices(l, val):
...     """Always returns a list containing the indices of val in the_list"""
...     return [index for index, value in enumerate(l) if value == val]
... 
>>> l = ['bar','foo','bar','baz','bar','bar']
>>> q = 'bar'
>>> print indices(l,q)
[0, 2, 4, 5]
>>> print indices(l,'bat')
[]
>>> print indices('abcdaababb','a')
[0, 4, 5, 7]
>>> 

E ora, dopo aver esaminato questa domanda e tutte le risposte, mi rendo conto che questo è esattamente ciò che suggerito nella sua precedente risposta . All'epoca in cui originariamente ho risposto a questa domanda, non ho nemmeno visto quella risposta, perché non l'ho capita. Spero che il mio esempio un po 'più verboso aiuti la comprensione.

Se la singola riga di codice sopra non ha ancora senso per te, ti raccomando caldamente la "comprensione di python list di Google" e prenditi qualche minuto per familiarizzare. È solo una delle molte potenti funzionalità che rendono piacevole l'utilizzo di Python per lo sviluppo del codice.


L'ho fatto per farlo funzionare:

import random_necessary
pick = ['Miss','Mrs','MiSs','Miss']
print  pick [int(random_necessary.random_necessary() * len(pick))]






python list