Python: buscar en la lista

Me he encontrado con esto:

item = someSortOfSelection()
if item in myList:
    doMySpecialFunction(item)

pero a veces no funciona con todos mis elementos, como si no fueran reconocidos en la lista (cuando es una lista de cadenas).

¿Es esta la forma más 'pitónica' de encontrar un elemento en una lista if x in l::?

En cuanto a su primera pregunta: ese código está perfectamente bien y debería funcionar si itemes igual a uno de los elementos internos myList. Tal vez intente encontrar una cadena que no coincida exactamente con uno de los elementos o tal vez esté utilizando un valor flotante que adolece de imprecisiones.

En cuanto a su segunda pregunta: en realidad hay varias formas posibles de "encontrar" cosas en listas.

Comprobando si hay algo dentro

Este es el caso de uso que describe: comprobar si algo está dentro de una lista o no. Como sabe, puede usar el inoperador para eso:

3 in [1, 2, 3] # => True

Filtrar una colección

Es decir, encontrar todos los elementos de una secuencia que cumplan una determinada condición. Puede usar la comprensión de listas o expresiones generadoras para eso:

matches = [x for x in lst if fulfills_some_condition(x)]
matches = (x for x in lst if x > 6)

Este último devolverá un generador que puede imaginar como una especie de lista perezosa que solo se creará tan pronto como lo recorra. Por cierto, el primero es exactamente equivalente a

matches = filter(fulfills_some_condition, lst)

en Python 2. Aquí puede ver funciones de orden superior en funcionamiento. En Python 3, filterno devuelve una lista, sino un objeto similar a un generador.

Encontrar la primera aparición

Si solo desea lo primero que coincida con una condición (pero aún no sabe qué es), está bien usar un bucle for (posiblemente también use la elsecláusula, que no es muy conocida). También puedes usar

next(x for x in lst if ...)

que devolverá la primera coincidencia o generará un StopIterationsi no se encuentra ninguna. Alternativamente, puede usar

next((x for x in lst if ...), [default value])

Encontrar la ubicación de un artículo

Para las listas, también existe el indexmétodo que a veces puede ser útil si desea saber dónde está un determinado elemento en la lista:

[1,2,3].index(2) # => 1
[1,2,3].index(4) # => ValueError

Sin embargo, tenga en cuenta que si tiene duplicados, .indexsiempre devuelve el índice más bajo: ......

[1,2,3,2].index(2) # => 1

Si hay duplicados y desea todos los índices, puede usar enumerate()en su lugar:

[i for i,x in enumerate([1,2,3,2]) if x==2] # => [1, 3]

Si desea encontrar un elemento o Noneusar el valor predeterminado en next, no aparecerá StopIterationsi el elemento no se encontró en la lista:

first_or_default = next((x for x in lst if ...), None)

Si bien la respuesta de Niklas B. es bastante completa, cuando queremos encontrar un elemento en una lista, a veces es útil obtener su índice:

next((i for i, x in enumerate(lst) if [condition on x]), [default value])

Encontrar la primera aparición

Hay una receta para eso en itertools:

def first_true(iterable, default=False, pred=None):
    """Returns the first true value in the iterable.

    If no true value is found, returns *default*

    If *pred* is not None, returns the first item
    for which pred(item) is true.

    """
    # first_true([a,b,c], x) --> a or b or c or x
    # first_true([a,b], x, f) --> a if f(a) else b if f(b) else x
    return next(filter(pred, iterable), default)

Por ejemplo, el siguiente código busca el primer número impar de una lista:

>>> first_true([2,3,4,5], None, lambda x: x%2==1)
3  

Otra alternativa: puedes comprobar si un artículo está en una lista con if item in list:, pero este es el orden O (n). Si está tratando con grandes listas de elementos y todo lo que necesita saber es si algo es miembro de su lista, puede convertir la lista en un conjunto primero y aprovechar la búsqueda constante de conjuntos de tiempo :

my_set = set(my_list)
if item in my_set:  # much faster on average than using a list
    # do something

No va a ser la solución correcta en todos los casos, pero en algunos casos esto podría brindarle un mejor rendimiento.

Tenga en cuenta que la creación del conjunto con set(my_list)también es O (n), por lo que si solo necesita hacer esto una vez, entonces no es más rápido hacerlo de esta manera. Sin embargo, si necesita verificar la membresía repetidamente, entonces esto será O (1) para cada búsqueda después de la creación del conjunto inicial.

Definición y uso

el count()método devuelve el número de elementos con el valor especificado.

Sintaxis

list.count(value)

ejemplo:

fruits = ['apple', 'banana', 'cherry']

x = fruits.count("cherry")

Ejemplo de pregunta:

item = someSortOfSelection()

if myList.count(item) >= 1 :

    doMySpecialFunction(item)

Es posible que desee utilizar una de las dos búsquedas posibles mientras trabaja con la lista de cadenas:

1. si el elemento de la lista es igual a un elemento ('ejemplo' está en ['uno', 'ejemplo', 'dos']):

   if item in your_list: some_function_on_true()

   'ex' en ['uno', 'ex', 'dos'] => Verdadero

   'ex_1' en ['uno', 'ex', 'dos'] => Falso

2. si el elemento de la lista es como un elemento ('ex' está en ['uno,' ejemplo ',' dos '] o' ejemplo_1 'está en [' uno ',' ejemplo ',' dos ']):

   matches = [el for el in your_list if item in el]

   o

   matches = [el for el in your_list if el in item]

   luego simplemente revíselos len(matches)o léalos si es necesario.

En lugar de usar list.index(x)que devuelve el índice de x si se encuentra en la lista o devuelve un #ValueErrormensaje si no se encuentra x, puede usar list.count(x)que devuelve el número de apariciones de x en la lista (validación de que x está de hecho en la lista) o devuelve 0 en caso contrario (en ausencia de x). Lo bueno de esto count()es que no rompe su código ni requiere que lance una excepción cuando no se encuentra x

Si va a verificar si existe un valor en el objeto de colección una vez, entonces usar el operador 'in' está bien. Sin embargo, si va a verificar más de una vez, le recomiendo usar el módulo bisect. 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. Usar el módulo bisect en mi máquina es aproximadamente 12 veces más rápido que usar el operador 'in'.

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 := bisect.bisect_left(container, value)) < len(container) 
      and container[index] == value
    )

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

# times to test
ttt = 1000

print(f"{bisect_search(data, true_value)=} {bisect_search(data, false_value)=}")

t1 = timeit(lambda: true_value in data, number=ttt)
t2 = timeit(lambda: bisect_search(data, true_value), number=ttt)

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

Salida:

bisect_search(data, true_value)=True bisect_search(data, false_value)=False
Performance: t1=0.0220, t2=0.0019, diffs t1/t2=11.71

Compruebe que no haya espacios en blanco adicionales / no deseados en los elementos de la lista de cadenas. Esa es una razón que puede estar interfiriendo al explicar que los elementos no se pueden encontrar.