La liste est un conteneur important en Python car elle stocke les éléments de tous les types de données sous forme de collection. La connaissance de certaines opérations de liste est nécessaire pour la programmation journalière. Cet article explique le moyen le plus rapide de vérifier si une valeur existe dans une liste ou si elle n'est pas utilisée. Python .

Exemple

  Input:   test_list = [1, 6, 3, 5, 3, 4]  3 # Check if 3 exist or not.   Output:   True   Explanation:   The output is True because the element we are looking is exist in the list.>

Vérifier si un élément existe dans une liste en Python

• En utilisant dans Déclaration
• Utilisant un boucle
• En utilisant fonction any()
• En utilisant compter() fonction
• En utilisant trier avec bisect_left et ensemble()
• En utilisant trouver() méthode
• En utilisant Comptoir() fonction
• En utilisant bloc try-sauf

Vérifiez si un élément existe dans la liste à l'aide du dans déclaration

Dans cette méthode, on utilise facilement une boucle qui parcourt tous les éléments pour vérifier l’existence de l’élément cible. C'est le moyen le plus simple de vérifier l'existence de l'élément dans la liste. Python est le moyen le plus conventionnel de vérifier si un élément existe ou non dans une liste. Cette méthode particulière renvoie True si un élément existe dans la liste et False si l'élément n'existe pas dans la liste. Il n'est pas nécessaire de trier la liste pour mettre en pratique cette approche de vérification.

char en int

lst=[ 1, 6, 3, 5, 3, 4 ] #checking if element 7 is present # in the given list or not i=7 # if element present then return # exist otherwise not exist if i in lst: print('exist') else: print('not exist')>

not exist>

Complexité temporelle : O(1)
Espace auxiliaire : O(n), où n est le nombre total d'éléments.

Rechercher si un élément existe dans la liste à l'aide d'une boucle

Le code Python donné initialise une liste nomméetest_list>avec quelques éléments entiers. Il parcourt ensuite chaque élément de la liste à l'aide d'unfor>boucle. À l'intérieur de boucle , il vérifie si l'élément couranti>est égal à la valeur 4 en utilisant unif>déclaration. Si la condition est vraie, l'élément existe sur la console. Le code affichera le message si le numéro 4 est présent dans la liste, et dans ce cas, l'élément existe sera imprimé puisque le numéro 4 existe dans la liste[1, 6, 3, 5, 3, 4]>.

# Initializing list test_list = [1, 6, 3, 5, 3, 4] # Checking if 4 exists in list for i in test_list: if(i == 4): print('Element Exists')>

Sortir:

Element Exists>

Complexité temporelle : Sur)
Espace auxiliaire : O(1)

Vérifiez si un élément existe dans la liste en utilisant la fonction any()

Il y parvient en utilisant le any()>fonction avec une expression génératrice. L'expression du générateur parcourt chaque élémenttest_list>et vérifie s'il apparaît plus d'une fois dans la liste. Le résultat de cette vérification est stocké dans la variableresult>. Enfin, le code imprime un message indiquant s'il y a des éléments en double, affichant La chaîne contient-elle un élément de liste : True si des doublons existent et La chaîne contient-elle un élément de liste : False s'il n'y a pas de doublons.

# Initializing list test_list = [1, 6, 3, 5, 3, 4] result = any(item in test_list for item in test_list) print('Does string contain any list element : ' +str(bool(result)))>

Sortir:

Does string contain any list element : True>

Rechercher si un élément existe dans la liste à l'aide de la fonction count()

Nous pouvons utiliser le Liste Python méthode, count(), pour vérifier si l’élément passé existe dans la liste. Si l'élément passé existe dans la Liste, le compter() La méthode affichera le nombre de fois où cela se produit dans la liste entière. S'il s'agit d'un nombre positif non nul, cela signifie qu'un élément existe dans la Liste. Démonstration pour vérifier l'existence d'éléments dans la liste en utilisant compter() .

# Initializing list test_list = [10, 15, 20, 7, 46, 2808] print('Checking if 15 exists in list') # number of times element exists in list exist_count = test_list.count(15) # checking if it is more than 0 if exist_count>0 : print('Oui, 15 existe dans la liste') else : print('Non, 15 n'existe pas dans la liste')>

Sortir:

Checking if 15 exists in list Yes, 15 exists in list>

Vérifiez si un élément existe dans la liste en utilisant le tri avec bisect_left et set

Conversion de la liste en ensemble, puis utilisation il peut éventuellement être plus efficace que de simplement l'utiliser. Mais avoir l’efficacité comme un plus présente également certains inconvénients. L'un d'entre eux est que l'ordre de la liste n'est pas conservé et si vous choisissez de créer une nouvelle liste, vous devrez utiliser de l'espace supplémentaire. Un autre inconvénient est que set interdit la duplicité et que les éléments en double seraient donc supprimés de la liste d'origine. Dans la manière conventionnelle de recherche binaire de tester l'existence des éléments, la liste doit donc être triée en premier et ne préserve donc pas l'ordre des éléments. bisect_left() renvoie la première occurrence de l'élément à trouver et a fonctionné de la même manière que borne inférieure() en C++ STL.

Note: La fonction bisect indiquera uniquement la position où insérer l'élément, mais pas les détails indiquant si l'élément est présent ou non.

combien de 0 sur un milliard

Démonstration pour vérifier l'existence d'un élément dans la liste en utilisant ensemble() + dans et trier() + bisect_left()

from bisect import bisect_left ,bisect # Initializing list  test_list_set = [ 1, 6, 3, 5, 3, 4 ] test_list_bisect = [ 1, 6, 3, 5, 3, 4 ] print('Checking if 4 exists in list ( using set() + in) : ') # Checking if 4 exists in list  # using set() + in test_list_set = set(test_list_set) if 4 in test_list_set : print ('Element Exists') print('Checking if 4 exists in list ( using sort() + bisect_left() ) : ') # Checking if 4 exists in list  # using sort() + bisect_left() test_list_bisect.sort() if bisect_left(test_list_bisect, 4)!=bisect(test_list_bisect, 4): print ('Element Exists') else: print('Element doesnt exist')>

Sortir:

Checking if 4 exists in list ( using set() + in) :  Element Exists Checking if 4 exists in list ( using sort() + bisect_left() ) :  Element Exists>

Vérifiez si un élément existe dans la liste en utilisant la méthode find()

Le donné Python le code vérifie si le numéro 15 existe dans la listetest_list>. Il convertit les éléments de la liste en chaînes et les concatène avec des traits d'union. Ensuite, il utilise le find()>méthode pour vérifier si la sous-chaîne 15 existe dans la chaîne résultante. Si 15 est trouvé, il imprime Oui, 15 existe dans la liste ; sinon, il imprime Non, 15 n'existe pas dans la liste.

# Initializing list test_list = [10, 15, 20, 7, 46, 2808] print('Checking if 15 exists in list') x=list(map(str,test_list)) y='-'.join(x) if y.find('15') !=-1: print('Yes, 15 exists in list') else: print('No, 15 does not exists in list')>

Checking if 15 exists in list Yes, 15 exists in list>

Vérifiez si l'élément existe dans la liste à l'aide de la fonction Counter()

Le code Python fourni utilise le Counter> classe de lacollections>module pour calculer la fréquence de chaque élément dans letest_list>. Il vérifie ensuite si la fréquence du nombre 15 est supérieure à 0. Si la fréquence est non nulle, cela signifie que 15 existe dans la liste et le code affiche Oui, 15 existe dans la liste. Sinon, il imprime Non, 15 n'existe pas dans la liste. LeCounter>la classe compte efficacement les occurrences d’éléments, permettant une vérification d’existence simple.

from collections import Counter test_list = [10, 15, 20, 7, 46, 2808] # Calculating frequencies frequency = Counter(test_list) # If the element has frequency greater than 0 # then it exists else it doesn't exist if(frequency[15]>0): print('Oui, 15 existe dans la liste') else: print('Non, 15 n'existe pas dans la liste')>

Yes, 15 exists in list>

Trouver si un un l'élément existe dans la liste en utilisant le bloc try-sauf

Une approche supplémentaire pour vérifier si un élément existe dans une liste consiste à utiliser le indice() méthode. Cette méthode renvoie l'index de la première occurrence de l'élément dans la liste ou renvoie une ValueError si l'élément n'est pas présent dans la liste. Pour utiliser cette méthode, vous pouvez envelopper l'appel à index() dans un bloc try-sauf pour intercepter ValueError et renvoyer False si cela se produit :

def element_exists(lst, element): # Try to get the index of the element in the list try: lst.index(element) # If the element is found, return True return True # If a ValueError is raised, the element is not in the list except ValueError: # Return False in this case return False #Test the function test_list = [1, 6, 3, 5, 3, 4] print(element_exists(test_list, 3)) # prints True print(element_exists(test_list, 7)) # prints False #This code is contributed by Edula Vinay Kumar Reddy>

True False>

Complexité temporelle : O(n), où n est la longueur de la liste. La méthode index() parcourt la liste pour trouver l’élément, la complexité temporelle est donc linéaire.
Complexité spatiale : O(1). Cette approche ne nécessite aucun espace supplémentaire.

Rechercher si un élément existe dans la liste à l'aide de la fonction filter()

Approche étape par étape

• Définissez la liste my_list et Set element_to_check.
• Utilisez la fonction filter() pour créer un itérateur (filtered_elements) qui contient des éléments égaux à element_to_check.
• Convertissez l'itérateur filtered_elements en liste.
• Cette étape est nécessaire car la fonction filter() renvoie un itérateur. La liste contient désormais des éléments égaux à element_to_check.
• Vérifiez si la liste filtered_list n'est pas vide.
• Si la liste n'est pas vide, cela signifie que l'élément existe dans la liste d'origine.

my_list = [1, 2, 3, 4, 5] element_to_check = 3 # Use filter to create an iterator of elements equal to the target element filtered_elements = filter(lambda x: x == element_to_check, my_list) # Convert the iterator to a list and check if it's not empty if list(filtered_elements): print('Element exists in the list') else: print('Element does not exist in the list')>

Element exists in the list>

Complexité temporelle : O(n)

Complexité de l'espace auxiliaire : O(n)