Encontrar el índice de un elemento en una lista

Dada una lista ["foo", "bar", "baz"] y un elemento en la lista "bar", ¿cómo obtengo su índice (1) en Python?

preguntado Oct 06 '08, 23:10

¿Regresa: [1] El índice más bajo en caso de que haya varias instancias de "bar", [2] Todos los índices de "bar"? -

a) ¿Está garantizado que el elemento está en la lista o, de lo contrario, cómo debemos manejar el caso de error? (return None / raise ValueError) b) ¿Se garantiza que las entradas de la lista sean únicas, y deberíamos devolver el primer índice de una coincidencia, o todos los índices? -

Vea las respuestas con la integración de numpy, los arreglos de numpy son mucho más eficientes que las listas de Python. Si la lista es corta, no hay problema para hacer una copia de ella desde una lista de Python, si no lo es, quizás debería considerar almacenar los elementos en una matriz numpy en primer lugar. -

30 Respuestas

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

Referencia: Estructuras de datos> Más sobre listas

Siguen las advertencias

Tenga en cuenta que si bien esta es quizás la forma más limpia de responder a la pregunta como se preguntó, index es un componente bastante débil de la list API, y no puedo recordar la última vez que lo usé con ira. Se me ha señalado en los comentarios que debido a que esta respuesta está muy referenciada, debería ser más completa. Algunas advertencias sobre list.index seguir. Probablemente valga la pena inicialmente echar un vistazo a la documentación:

list.index(x[, start[, end]])

Devuelve un índice de base cero en la lista del primer elemento cuyo valor es igual a x. Plantea un ValueError si no existe tal artículo.

Los argumentos opcionales comienzo y final se interpretan como en el notación de corte y se utilizan para limitar la búsqueda a una subsecuencia particular de la lista. El índice devuelto se calcula en relación con el comienzo de la secuencia completa en lugar del argumento de inicio.

Complejidad de tiempo lineal en la longitud de la lista

An index call comprueba todos los elementos de la lista en orden, hasta que encuentra una coincidencia. Si su lista es larga y no sabe aproximadamente en qué lugar de la lista aparece, esta búsqueda podría convertirse en un cuello de botella. En ese caso, debería considerar una estructura de datos diferente. Tenga en cuenta que si sabe aproximadamente dónde encontrar la coincidencia, puede dar index una pista. Por ejemplo, en este fragmento, l.index(999_999, 999_990, 1_000_000) es aproximadamente cinco órdenes de magnitud más rápido que directo l.index(999_999), porque el primero solo tiene que buscar 10 entradas, mientras que el segundo busca un millón:

>>> import timeit
>>> timeit.timeit('l.index(999_999)', setup='l = list(range(0, 1_000_000))', number=1000)
9.356267921015387
>>> timeit.timeit('l.index(999_999, 999_990, 1_000_000)', setup='l = list(range(0, 1_000_000))', number=1000)
0.0004404920036904514
 

Solo devuelve el índice del primer partido a su argumento

Una llamada a index busca en la lista en orden hasta que encuentra una coincidencia, y se detiene allí. Si espera necesitar índices de más coincidencias, debe usar una comprensión de lista o una expresión generadora.

>>> [1, 1].index(1)
0
>>> [i for i, e in enumerate([1, 2, 1]) if e == 1]
[0, 2]
>>> g = (i for i, e in enumerate([1, 2, 1]) if e == 1)
>>> next(g)
0
>>> next(g)
2

La mayoría de los lugares donde alguna vez habría usado index, Ahora uso una lista de comprensión o una expresión generadora porque son más generalizables. Entonces, si estás considerando alcanzar index, eche un vistazo a estas excelentes características de Python.

Lanza si el elemento no está presente en la lista

Una llamada a index resulta en un ValueError si el artículo no está presente.

>>> [1, 1].index(2)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: 2 is not in list

Si el elemento puede no estar presente en la lista, debe

  1. Compruébelo primero con item in my_list (enfoque limpio y legible), o
  2. Envolver el index llamar a un try/except bloque que atrapa ValueError (probablemente más rápido, al menos cuando la lista de búsqueda es larga y el elemento suele estar presente).

Respondido el 20 de junio de 20 a las 10:06

index devuelve el primer elemento cuyo valor es "bar". Si "barra" existe dos veces en la lista, nunca encontrará la clave para la segunda "barra". Ver documentación: docs.python.org/3/tutorial/datastructures.html - mpoletto

Si solo está buscando un elemento (el primero), encontré que index() es un 90% más rápido que la comprensión de listas frente a listas de números enteros. - astuto

¿Qué estructura de datos debería usarse si la lista es muy larga? - izhang05

@izhang: Algún índice auxiliar, como un dict {element -> list_index}, si los elementos son hash y la posición en la lista es importante. - Alex Coventry

secuencia1 = ordenada (secuencia2, clave = .secuencia3.index) es un modismo muy útil. Puede usar el índice con más frecuencia si está en su repertorio. - DVD Avins

Una cosa que es realmente útil para aprender Python es usar la función de ayuda interactiva:

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

class list(object)
 ...

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

que a menudo le llevará al método que está buscando.

Respondido 07 Oct 08, 14:10

bpython es una forma agradable y fácil de usar de leer los documentos de forma interactiva. - goetzc

@davidavr sí, pero el resto de nosotros que solo queremos buscarlo en Google en lugar de desplazarnos por los documentos de ayuda no tendríamos este bonito conjunto de opciones centralizadas y clasificadas. :) - cydoniano

La mayoría de las respuestas explican cómo encontrar un solo índice, pero sus métodos no devuelven varios índices si el elemento está en la lista varias veces. Usar enumerate():

for i, j in enumerate(['foo', 'bar', 'baz']):
    if j == 'bar':
        print(i)

Los programas index() función solo devuelve la primera aparición, mientras que enumerate() devuelve todas las apariciones.

Como una lista de comprensión:

[i for i, j in enumerate(['foo', 'bar', 'baz']) if j == 'bar']

Aquí también hay otra pequeña solución con itertools.count() (que es más o menos el mismo enfoque que enumerar):

from itertools import izip as zip, count # izip for maximum efficiency
[i for i, j in zip(count(), ['foo', 'bar', 'baz']) if j == 'bar']

Esto es más eficiente para listas más grandes que usar enumerate():

$ python -m timeit -s "from itertools import izip as zip, count" "[i for i, j in zip(count(), ['foo', 'bar', 'baz']*500) if j == 'bar']"
10000 loops, best of 3: 174 usec per loop
$ python -m timeit "[i for i, j in enumerate(['foo', 'bar', 'baz']*500) if j == 'bar']"
10000 loops, best of 3: 196 usec per loop

Respondido el 21 de enero de 20 a las 13:01

La enumeración funciona mejor que los métodos basados ​​en índices para mí, ya que busco recopilar los índices de cadenas usando "startswith", y necesito recopilar varias ocurrencias. ¿O hay alguna forma de usar index with "startswith" que no pude entender - Cardo de tupelo

En mis manos, la versión enumerada es consistentemente un poco más rápida. Es posible que algunos detalles de implementación hayan cambiado desde que se publicó la medición anterior. - Alex Coventry

Esto ya fue respondido desde el '11: stackoverflow.com/questions/6294179/… - cristik

¡Qué ahorrador de una respuesta! gracias !! .. Intenté durante 2 días obtener el índice de un diccionario anidado antes de entender que podíamos usar enumerate - Viv

Para obtener todos los índices:

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

Respondido 30 Jul 19, 12:07

Ya hay otra pregunta para esto, agregada en '11: stackoverflow.com/questions/6294179/… - cristik

index() devuelve el en el primer índice de valor!

| índice(...)
| L.index (valor, [inicio, [parada]]) -> entero - devuelve el primer índice del valor

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

respondido 09 mar '12, 10:03

¿Y si no existe en la lista? - Pedro Mortensen

El elemento que no existe generará ValueError - Nam G VU

Esta respuesta encajaría mejor aquí: stackoverflow.com/questions/6294179/… - cristik

Surgirá un problema si el elemento no está en la lista. Esta función maneja el 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

Respondido 24 Abr '17, 11:04

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

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

Respondido 31 Oct 17, 07:10

Esta respuesta debería publicarse mejor aquí: stackoverflow.com/questions/6294179/… - cristik

Debe establecer una condición para verificar si el elemento que está buscando está en la lista

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

contestado el 26 de mayo de 14 a las 05:05

¡Esto nos ayuda a evitar intentar atrapar! - devssh

Sin embargo, podría duplicar la complejidad. ¿Alguien lo comprobó? - Stefanct

@stefanct La complejidad del tiempo sigue siendo lineal, pero recorrerá la lista dos veces. - Acercándose Oscuridad

@ApproachingDarknessFish Eso es obviamente lo que quise decir. Aunque pedante es lo mismo solicite de complejidad, iterar dos veces podría ser una gran desventaja en muchos casos de uso, por lo que lo mencioné. Y todavía no sabemos la respuesta ... - Stefanct

Todas las funciones propuestas aquí reproducen el comportamiento inherente del lenguaje pero oscurecen lo que está sucediendo.

[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

¿Por qué escribir una función con manejo de excepciones si el lenguaje proporciona los métodos para hacer lo que quiere por sí mismo?

Respondido el 24 de diciembre de 16 a las 14:12

El tercer método itera dos veces sobre la lista, ¿verdad? - eric duminil

Re: "Todas las funciones propuestas aquí": Quizás en el momento de escribir este artículo, pero debería comprobar las respuestas más recientes para ver si todavía es cierto. - Pedro Mortensen

Si desea todos los índices, puede usar 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),)

Es una solución clara y legible.

Respondido el 04 de junio de 18 a las 21:06

¿Qué pasa con las listas de cadenas, listas de objetos no numéricos, etc.? - laringe decidua

Esta respuesta debería publicarse mejor aquí: stackoverflow.com/questions/6294179/… - cristik

Este es el mejor que he leído. Las matrices numpy son mucho más eficientes que las listas de Python. Si la lista es corta, no hay problema para hacer una copia de ella desde una lista de Python, si no lo es, quizás el desarrollador debería considerar almacenar los elementos en una matriz numpy en primer lugar. - Atanasio

Encontrar el índice de un elemento dada una lista que lo contiene en Python

Para una lista ["foo", "bar", "baz"] y un elemento en la lista "bar", ¿cuál es la forma más limpia de obtener su índice (1) en Python?

Bueno, claro, está el método de índice, que devuelve el índice de la primera aparición:

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

Hay un par de problemas con este método:

  • si el valor no está en la lista, obtendrá un ValueError
  • si hay más de uno de los valores en la lista, solo obtiene el índice del primero

Sin valores

Si el valor puede faltar, necesita capturar el ValueError.

Puede hacerlo con una definición reutilizable como esta:

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

Y utilícelo así:

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

Y la desventaja de esto es que probablemente tendrá una verificación para ver si el valor devuelto is or is not Ninguno:

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

Más de un valor en la lista

Si pudiera tener más ocurrencias, no obtener información completa con list.index:

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

Puede enumerar en una lista de comprensión los índices:

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

Si no tiene ocurrencias, puede verificarlo con una verificación booleana del resultado, o simplemente no hacer nada si recorre los resultados:

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

Mejor intercambio de datos con pandas

Si tiene pandas, puede obtener fácilmente esta información con un objeto Series:

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

Una comprobación de comparación devolverá una serie de valores booleanos:

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

Pase esa serie de valores booleanos a la serie a través de la notación de subíndice y obtendrá solo los miembros coincidentes:

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

Si solo desea los índices, el atributo de índice devuelve una serie de números enteros:

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

Y si los quiere en una lista o tupla, simplemente páselos al constructor:

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

Sí, también podría usar una lista de comprensión con enumerate, pero eso no es tan elegante, en mi opinión: está haciendo pruebas de igualdad en Python, en lugar de dejar que el código incorporado escrito en C lo maneje:

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

Es esto un Problema XY?

El problema XY es preguntar sobre su intento de solución en lugar de su problema real.

¿Por qué cree que necesita el índice dado un elemento en una lista?

Si ya conoce el valor, ¿por qué le importa dónde está en una lista?

Si el valor no está ahí, capturando el ValueError es bastante detallado, y prefiero evitarlo.

Normalmente estoy iterando sobre la lista de todos modos, por lo que normalmente mantengo un puntero a cualquier información interesante, obteniendo índice con enumerar.

Si está manipulando datos, probablemente debería usar pandas, que tiene herramientas mucho más elegantes que las soluciones alternativas puras de Python que he mostrado.

No recuerdo haber necesitado list.index, yo mismo. Sin embargo, he revisado la biblioteca estándar de Python y veo algunos usos excelentes para ella.

Hay muchos, muchos usos para él en idlelib, para GUI y análisis de texto.

Los programas keyword El módulo lo usa para encontrar marcadores de comentarios en el módulo para regenerar automáticamente la lista de palabras clave en él a través de la metaprogramación.

En Lib / mailbox.py parece estar usándolo como un mapeo ordenado:

key_list[key_list.index(old)] = new

y

del key_list[key_list.index(key)]

En Lib / http / cookiejar.py, parece que se usa para obtener el mes siguiente:

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

En Lib / tarfile.py similar a distutils para obtener una porción de un artículo:

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

En Lib / pickletools.py:

numtopop = before.index(markobject)

Lo que estos usos parecen tener en común es que parecen operar en listas de tamaños restringidos (importante debido al tiempo de búsqueda O (n) para list.index), y se utilizan principalmente en el análisis (y la interfaz de usuario en el caso de inactivo).

Si bien existen casos de uso para ello, son bastante poco comunes. Si se encuentra buscando esta respuesta, pregúntese si lo que está haciendo es el uso más directo de las herramientas proporcionadas por el lenguaje para su caso de uso.

Respondido el 20 de junio de 20 a las 10:06

Obtener todas las ocurrencias y la posición de uno o más elementos (idénticos) en una lista

Con enumerate (alist) puedes almacenar el primer elemento (n) que es el índice de la lista cuando el elemento x es igual a lo que buscas.

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

Hagamos nuestra función findindex

Esta función toma el elemento y la lista como argumentos y devuelve la posición del elemento en la lista, como vimos antes.

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

Salida


[1, 3, 5, 7]

Sencillo

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

Salida:

0
4

respondido 05 nov., 18:12

Esta respuesta debería publicarse mejor aquí: stackoverflow.com/questions/6294179/… - cristik

Todos los índices con el zip función:

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

Respondido el 04 de junio de 18 a las 21:06

Esta respuesta debería publicarse mejor aquí: stackoverflow.com/questions/6294179/… - cristik

Simplemente puedes ir con

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

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

contestado el 29 de mayo de 13 a las 08:05

Otra opción

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

contestado el 29 de mayo de 13 a las 20:05

Esta respuesta debería publicarse mejor aquí: stackoverflow.com/questions/6294179/… - cristik

Y ahora para algo completamente diferente...

... como confirmar la existencia del artículo antes de obtener el índice. Lo bueno de este enfoque es que la función siempre devuelve una lista de índices, incluso si es una lista vacía. También funciona con cuerdas.

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

Cuando se pega en una ventana interactiva de Python:

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

Noticias

Después de otro año de desarrollo de Python de cabeza hacia abajo, estoy un poco avergonzado por mi respuesta original, así que para dejar las cosas claras, ciertamente se puede usar el código anterior; sin embargo, el mucho más Una forma más idiomática de obtener el mismo comportamiento sería usar la comprensión de listas, junto con la función enumerate ().

Algo como esto:

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

Lo cual, cuando se pega en una ventana interactiva de Python, 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]
>>> 

Y ahora, después de revisar esta pregunta y todas las respuestas, me doy cuenta de que esto es exactamente lo que FMc sugirió en su respuesta anterior. En el momento en que respondí originalmente a esta pregunta, ni siquiera ver esa respuesta, porque no la entendí. Espero que mi ejemplo algo más detallado ayude a la comprensión.

Si la única línea de código de arriba todavía no se tiene sentido para usted, le recomiendo encarecidamente que Google "comprensión de la lista de Python" y tómese unos minutos para familiarizarse. Es solo una de las muchas características poderosas que hacen que sea un placer usar Python para desarrollar código.

Respondido 18 Jul 18, 11:07

Una variante de la respuesta de FMc y user7177 dará un dict que puede devolver todos los índices para cualquier entrada:

>>> a = ['foo','bar','baz','bar','any', 'foo', 'much']
>>> l = dict(zip(set(a), map(lambda y: [i for i,z in enumerate(a) if z is y ], set(a))))
>>> l['foo']
[0, 5]
>>> l ['much']
[6]
>>> l
{'baz': [2], 'foo': [0, 5], 'bar': [1, 3], 'any': [4], 'much': [6]}
>>> 

También puede usar esto como una línea para obtener todos los índices para una sola entrada. No hay garantías de eficiencia, aunque utilicé el conjunto (a) para reducir la cantidad de veces que se llama a lambda.

respondido 28 mar '14, 09:03

Esta respuesta debería publicarse mejor aquí: stackoverflow.com/questions/6294179/… - cristik

Encontrar el índice del elemento x en la lista L:

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

Respondido el 30 de enero de 19 a las 17:01

Esto itera la matriz dos veces, por lo que podría resultar en problemas de rendimiento para matrices grandes. - cristik

Estar de acuerdo. Si las listas son considerablemente largas, optaría por otra cosa. Sin embargo, no debería ser un gran problema para las listas pequeñas y medianas. - Ketan

Esta solución no es tan poderosa como otras, pero si eres un principiante y solo conoces forbucles, todavía es posible encontrar el primer índice de un elemento evitando el ValueError:

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

respondido 12 nov., 17:06

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)

Esto tiene en cuenta si la cadena no está en la lista también, si no está en la lista, entonces location = -1

Respondido 13 Feb 20, 13:02

Python index() El método arroja un error si no se encontró el elemento. Entonces, en su lugar, puede hacerlo similar al indexOf() función de JavaScript que devuelve -1 si no se encontró el artículo:

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

Respondido 30 Jul 19, 12:07

sin embargo, JavaScript tiene la filosofía de que los resultados extraños son mejores que los errores, por lo que tiene sentido devolver -1, pero en Python, puede ser difícil rastrear el error, ya que -1 devuelve un elemento del final de la lista. - Zafiro_Ladrillo

Dado que las listas de Python están basadas en cero, podemos usar la función integrada zip de la siguiente manera:

>>> [i for i,j in zip(range(len(haystack)), haystack) if j == 'needle' ]

donde "pajar" es la lista en cuestión y "aguja" es el elemento a buscar.

(Nota: aquí estamos iterando usando i para obtener los índices, pero si necesitamos enfocarnos en los elementos, podemos cambiar a j).

Respondido el 04 de junio de 18 a las 21:06

[i para i, j en enumerate (pajar) si j == 'aguja'] es más compacto y legible, creo. - Giovanni G. PY

Hay una respuesta más funcional a esto.

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

Forma más genérica:

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

Respondido el 04 de junio de 18 a las 21:06

Esta respuesta se siente como en casa para Scala / programación funcional entusiastas - y2k-shubham

Cuando solo se necesita un valor en una lista que tiene muchas coincidencias, este toma mucho tiempo. - Cavernícola

Para aquellos que vienen de otro idioma como yo, tal vez con un bucle simple es más fácil de entender y usar:

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

estoy agradecido por Entonces, ¿qué hace exactamente enumerar?. Eso me ayudó a comprender.

Respondido el 04 de junio de 18 a las 21:06

Vamos a dar el nombre lst a la lista que tienes. Uno puede convertir la lista lst a una numpy array. Y luego usa numpy donde para obtener el índice del elemento elegido en la lista. A continuación se muestra la forma en que lo implementará.

import numpy as np

lst = ["foo", "bar", "baz"]  #lst: : 'list' data type
print np.where( np.array(lst) == 'bar')[0][0]

>>> 1

respondido 28 nov., 18:06

No funciona si el elemento es una instancia de una clase. Cavernícola

Existe la posibilidad de que ese valor no esté presente, por lo que para evitar este ValueError, podemos verificar si realmente existe en la lista.

list =  ["foo", "bar", "baz"]

item_to_find = "foo"

if item_to_find in list:
      index = list.index(item_to_find)
      print("Index of the item is " + str(index))
else:
    print("That word does not exist") 

Respondido 28 ago 20, 10:08

Por uno comparable

# Throws ValueError if nothing is found
some_list = ['foo', 'bar', 'baz'].index('baz')
# some_list == 2

Predicado personalizado

some_list = [item1, item2, item3]

# Throws StopIteration if nothing is found
# *unless* you provide a second parameter to `next`
index_of_value_you_like = next(
    i for i, item in enumerate(some_list)
    if item.matches_your_criteria())

Encontrar índice de todos los elementos por predicado

index_of_staff_members = [
    i for i, user in enumerate(users)
    if user.is_staff()]

Respondido el 10 de diciembre de 20 a las 11:12

idx = next((i for i, v in enumerate(ls) if v == chk), -1) para obtener un comportamiento similar a str.index (chk). - tejasvi88

@ tejasvi88 Decidió poner un poco de trabajo extra en la respuesta - Cavernícola

Si el rendimiento es motivo de preocupación:

En numerosas respuestas se menciona que el método incorporado de list.index(item) El método es un algoritmo O (n). Está bien si necesita realizar esto una vez. Pero si necesita acceder a los índices de elementos varias veces, tiene más sentido crear primero un diccionario (O (n)) de pares de índice de elemento y luego acceder al índice en O (1) cada vez que lo necesite eso.

Si está seguro de que los elementos de su lista nunca se repiten, puede fácilmente:

myList = ["foo", "bar", "baz"]

# Create the dictionary
myDict = dict((e,i) for i,e in enumerate(myList))

# Lookup
myDict["bar"] # Returns 1
# myDict.get("blah") if you don't want an error to be raised if element not found.

Si puede tener elementos duplicados y necesita devolver todos sus índices:

from collections import defaultdict as dd
myList = ["foo", "bar", "bar", "baz", "foo"]

# Create the dictionary
myDict = dd(list)
for i,e in enumerate(myList):
    myDict[e].append(i)

# Lookup
myDict["foo"] # Returns [0, 4]

Respondido el 10 de Septiembre de 18 a las 19:09

Si va a encontrar un índice una vez, entonces está bien usar el método "índice". Sin embargo, si va a buscar sus datos más de una vez, le recomiendo usar bisecar módulo. Tenga en cuenta que el uso de datos de módulos bisectados debe ordenarse. Así que clasifica los datos una vez y luego puede usar bisect. Utilizando bisecar El módulo en mi máquina es aproximadamente 20 veces más rápido que usar el método de índice.

A continuación, se muestra un ejemplo de código que utiliza la sintaxis de Python 3.8 y superior:

import bisect
from timeit import timeit

def bisect_search(container, value):
    return (
      index 
      if (index := bisect.bisect_left(container, value)) < len(container) 
      and container[index] == value else -1
    )

data = list(range(1000))
# value to search
value = 666

# times to test
ttt = 1000

t1 = timeit(lambda: data.index(value), number=ttt)
t2 = timeit(lambda: bisect_search(data, value), number=ttt)

print(f"{t1=:.4f}, {t2=:.4f}, diffs {t1/t2=:.2f}")

Salida:

t1=0.0400, t2=0.0020, diffs t1/t2=19.60

Respondido 03 Abr '20, 17:04

Como lo indica @TerryA, muchas respuestas discuten cómo encontrar . índice.

more_itertools es una biblioteca de terceros con herramientas para localizar múltiples índices dentro de un iterable.

Dado

import more_itertools as mit


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

Código

Encuentre índices de múltiples observaciones:

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

Pruebe varios elementos:

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

Ver también más opciones con more_itertools.locate. Instalar a través de > pip install more_itertools.

Respondido el 25 de Septiembre de 18 a las 16:09

No es la respuesta que estás buscando? Examinar otras preguntas etiquetadas or haz tu propia pregunta.