"in de Python ” opérateur est un mot-clé réservé pour tester l'appartenance de l'opérande gauche dans la collection définie comme opérande droit. Par exemple, l'expression x in my_list checks si objet x existe dans le my_list collection, de sorte qu'au moins un élément y existe en my_list pour ce x == y tient. Vous pouvez vérifier l'adhésion en utilisant le "in ” opérateur dans des collections telles que des listes, des ensembles, des chaînes et des tuples.
La vérification de l'appartenance est illustrée dans l'extrait de code suivant (voir Figure 1 ):
>>> item = 42 >>> my_list = list(range(1, 43)) >>> item in my_list True
Voici un autre exemple sur les chaînes :
x = 'alice' my_list = ['alice', 'bob', 'carl'] print(x in my_list) # True
En fait, Python a deux opérateurs d'appartenance in et not in qui testent si une valeur existe dans une collection telle qu'une chaîne, une liste, un tuple, un ensemble et un dictionnaire.
| Opérateur | Signification | Exemple |
|---|---|---|
in | True si la valeur/variable est trouvée dans la séquence | x in my_list |
not in | True si la valeur/variable n'est pas trouvée dans la séquence | x not in my_list |
Abonnement vidéo
Chaîne d'opérateur "in" Python
Vous pouvez vérifier l'appartenance d'un personnage dans une chaîne en utilisant le "in ” opérateur de mot-clé. Par exemple, l'expression 'f' in 'finxter' renvoie True car le caractère 'f' existe dans la chaîne 'finxter' .
>>> 'f' in 'finxter' True
Vous pouvez également vérifier l'appartenance à une chaîne dans une autre chaîne en utilisant le "in ” opérateur. Par exemple, l'expression 'inx' in 'finxter' renvoie True car la chaîne 'inx' existe dans la chaîne 'finxter' .
>>> 'inx' in 'finxter' True
Liste des opérateurs "in" Python
Vous pouvez vérifier l'appartenance d'un objet individuel dans une liste en utilisant le "in ” opérateur de mot-clé. Par exemple, l'expression 42 in [1, 2, 42] renvoie True car l'entier 42 existe dans la liste [1, 2, 42]
>>> 42 in [1, 2, 42] True >>> 'finxter' in ['finxter', 'learn', 'python'] True
Cependant, vous ne pouvez pas vérifier si une sous-liste existe dans une liste plus grande comme ceci :
>>> [1, 2] in [1, 2, 3] False
La raison en est que la sous-liste est un objet lui-même et l'appartenance vérifie uniquement si cet objet particulier est dans la liste. Par exemple, vous pouvez vérifier si une liste est membre de la liste des listes.
Ensemble d'opérateurs "in" Python
Vous pouvez vérifier l'appartenance d'un objet individuel dans un ensemble avec le "in ” opérateur de mot-clé. Par exemple, l'expression 42 in {1, 2, 42} renvoie True car l'entier 42 existe dans l'ensemble {1, 2, 42}
>>> 42 in {1, 2, 42}
True
>>> 'finxter' in {'finxter', 'learn', 'python'}
True Dictionnaire des opérateurs "in" de Python
Vous pouvez vérifier l'appartenance à une clé individuelle dans un dictionnaire avec le "in ” opérateur de mot-clé. Par exemple, l'expression 'a' in {'a': 1, 'b': 2} renvoie True car la clé de chaîne existe dans le dictionnaire.
>>> 'a' in {'a': 1, 'b': 2}
True
>>> 'c' in {'a': 1, 'b': 2}
False
>>> 42 in {42: [1, 2], 22: [3, 4]}
True Opérateur Python "in" insensible à la casse
Une vérification insensible à la casse si une chaîne donnée se trouve dans une liste de chaînes, en ignorant si les chaînes sont en majuscules ou en minuscules, peut être effectuée en convertissant toutes les chaînes en une représentation canonique en minuscules (ou majuscules) à l'aide de string.lower() ou string.upper() méthodes, par exemple, dans une déclaration de compréhension de liste.
Voici comment cela fonctionne :
>>> user = 'ALICE' >>> usernames = ['alice', 'bob', 'CARL'] >>> user.lower() in [x.lower() for x in usernames] True
- Convertir la chaîne
'ALICE'à la version minuscule'alice'. - Convertir la liste de chaînes
['alice', 'bob', 'CARL']aux versions minuscules['alice', 'bob', 'carl'].
Surcharge d'opérateur Python "in"
La surcharge d'opérateur remplace la signification standard d'un opérateur par une version personnalisée. Vous pouvez surcharger le "in ” opérateur en remplaçant le __contains__(self, item) méthode et renvoie une valeur booléenne True ou False si l'élément existe dans l'objet de classe personnalisé ou non.
Voici un exemple général :
class MyClass:
def __init__(self, my_collection):
self.my_collection = my_collection
def __contains__(self, item):
return item in self.my_collection
my = MyClass('hello world')
print('hello' in my)
# True
La classe personnalisée MyClass ne soutiendrait généralement pas l'adhésion. Mais en définissant le __contains__() "dunder", vous pouvez réduire l'appartenance d'un objet à la classe au problème de vérification de l'appartenance d'un objet à une collection à l'aide de la méthode "in ” opérateur. Maintenant, vous pouvez vérifier, par exemple, si une chaîne est membre d'un objet de classe personnalisé.
Complexité d'exécution de l'opérateur Python "in"
Le tableau suivant montre les complexités d'exécution du "in ” opérateur pour différentes structures de données de collecte de base avec n éléments.
| Type de collecte | Complexité d'exécution |
|---|---|
| liste | O(n) |
| définir | O(1) |
| dict | O(1) |
| uplet | O(n) |
| chaîne | O(n) |
La vérification de l'appartenance aux listes, tuples et chaînes a une complexité d'exécution linéaire. Python itère sur l'ensemble de la collection et compare l'élément recherché à chaque élément de la collection. Pour les grandes collections, vérifier l'adhésion peut devenir prohibitif.
La vérification de l'appartenance des ensembles et des dictionnaires présente une complexité d'exécution constante. Python utilise une table de hachage pour vérifier instantanément si un élément se trouve dans l'ensemble ou le dict, quelle que soit la taille de la structure de données. Surtout pour les grandes collections telles que n=10000 éléments, les ensembles doivent généralement être préférés aux listes et aux tuples.
