Python: Rechercher dans la liste

Je suis tombé sur ceci:

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

mais parfois cela ne fonctionne pas avec tous mes éléments, comme s'ils n'étaient pas reconnus dans la liste (quand c'est une liste de chaîne).

Est - ce la façon la plus « pythonique » de trouver un élément dans une liste: if x in l:?

Quant à votre première question: ce code est parfaitement bien et devrait fonctionner s'il itemest égal à l'un des éléments à l'intérieur myList. Peut-être que vous essayez de trouver une chaîne qui ne correspond pas exactement à l'un des éléments ou que vous utilisez une valeur flottante qui souffre d'inexactitude.

Quant à votre deuxième question: il existe en fait plusieurs façons possibles de "trouver" des choses dans les listes.

Vérifier si quelque chose est à l'intérieur

Voici le cas d'utilisation que vous décrivez: Vérifier si quelque chose se trouve dans une liste ou non. Comme vous le savez, vous pouvez utiliser l' inopérateur pour cela:

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

Filtrer une collection

Autrement dit, trouver tous les éléments dans une séquence qui remplissent une certaine condition. Vous pouvez utiliser la compréhension de liste ou des expressions génératrices pour cela:

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

Ce dernier renverra un générateur que vous pouvez imaginer comme une sorte de liste paresseuse qui ne sera construite que lorsque vous l'itérerez. Soit dit en passant, le premier est exactement équivalent à

matches = filter(fulfills_some_condition, lst)

en Python 2. Ici, vous pouvez voir des fonctions d'ordre supérieur à l'œuvre. En Python 3, filterne renvoie pas de liste, mais un objet de type générateur.

Trouver la première occurrence

Si vous ne voulez que la première chose qui corresponde à une condition (mais vous ne savez pas encore ce que c'est), c'est bien d'utiliser une boucle for (éventuellement en utilisant également la elseclause, qui n'est pas vraiment bien connue). Vous pouvez aussi utiliser

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

qui retournera la première correspondance ou lèvera un StopIterationsi aucun n'est trouvé. Vous pouvez également utiliser

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

Recherche de l'emplacement d'un élément

Pour les listes, il y a aussi la indexméthode qui peut parfois être utile si vous voulez savoir où se trouve un certain élément dans la liste:

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

Cependant, notez que si vous avez des doublons, .indexrenvoie toujours l'index le plus bas: ......

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

S'il y a des doublons et que vous voulez tous les index, vous pouvez utiliser à la enumerate()place:

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

Si vous voulez trouver un élément ou Noneutiliser la valeur par défaut dans next, il ne se lèvera pas StopIterationsi l'élément n'a pas été trouvé dans la liste:

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

Bien que la réponse de Niklas B. soit assez complète, lorsque nous voulons trouver un élément dans une liste, il est parfois utile d'obtenir son index:

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

Trouver la première occurrence

Il y a une recette pour ça dans 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)

Par exemple, le code suivant recherche le premier nombre impair dans une liste:

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

Une autre alternative: vous pouvez vérifier si un élément est dans une liste avec if item in list:, mais c'est l'ordre O (n). Si vous avez affaire à de grandes listes d'éléments et que tout ce que vous devez savoir est si quelque chose fait partie de votre liste, vous pouvez d'abord convertir la liste en un ensemble et profiter de la recherche d'un ensemble de temps constant :

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

Cela ne sera pas la bonne solution dans tous les cas, mais dans certains cas, cela pourrait vous donner de meilleures performances.

Notez que la création de l'ensemble avec set(my_list)est également O (n), donc si vous n'avez besoin de le faire qu'une seule fois, il n'est pas plus rapide de le faire de cette façon. Si vous devez vérifier à plusieurs reprises l'appartenance, ce sera O (1) pour chaque recherche après la création de l'ensemble initial.

Vous souhaiterez peut-être utiliser l'une des deux recherches possibles lorsque vous travaillez avec une liste de chaînes:

1. si l'élément de liste est égal à un élément ('exemple' est dans ['un', 'exemple', 'deux']):

   if item in your_list: some_function_on_true()

   'ex' dans ['un', 'ex', 'deux'] => Vrai

   'ex_1' dans ['un', 'ex', 'deux'] => Faux

2. si l'élément de liste est comme un élément ('ex' est dans ['un,' exemple ',' deux '] ou' exemple_1 'est dans [' un ',' exemple ',' deux ']):

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

   ou

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

   vérifiez-les len(matches)ou lisez-les si nécessaire.

Définition et utilisation

la count()méthode renvoie le nombre d'éléments avec la valeur spécifiée.

Syntaxe

list.count(value)

exemple:

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

x = fruits.count("cherry")

Exemple de question:

item = someSortOfSelection()

if myList.count(item) >= 1 :

    doMySpecialFunction(item)

Au lieu d'utiliser list.index(x)qui renvoie l'index de x s'il se trouve dans la liste ou renvoie un #ValueErrormessage si x n'est pas trouvé, vous pouvez utiliser list.count(x)qui renvoie le nombre d'occurrences de x dans la liste (validation que x est bien dans la liste) ou renvoie 0 sinon (en l'absence de x). Ce qui est cool, count()c'est qu'il ne casse pas votre code ou vous oblige à lever une exception lorsque x n'est pas trouvé

Si vous allez vérifier si la valeur existe une fois dans la collection, alors utiliser l'opérateur 'in' est correct. Cependant, si vous allez vérifier plus d'une fois, je vous recommande d'utiliser le module bissect. Gardez à l'esprit que l'utilisation des données du module bissect doit être triée. Vous triez donc les données une fois et vous pouvez ensuite utiliser la bissect. L'utilisation du module bissect sur ma machine est environ 12 fois plus rapide que l'utilisation de l'opérateur 'in'.

Voici un exemple de code utilisant Python 3.8 et la syntaxe ci-dessus:

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

Production:

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

Vérifiez qu'il n'y a pas d'espace blanc supplémentaire / indésirable dans les éléments de la liste des chaînes. C'est une raison qui peut interférer en expliquant que les articles sont introuvables.