"not in de Python ” l'opérateur vérifie l'adhésion négative d'un objet dans une collection. Il est composé des deux mots clés réservés "in ” pour tester l'appartenance de l'opérande de gauche à la collection d'opérandes de droite, et “not ” pour inverser logiquement le résultat. L'expression x not in y vérifie si l'objet x n'existe pas dans la collection y . L'existence est testée à l'aide de l'opérateur d'égalité == . Vous pouvez vérifier l'adhésion en utilisant le "not in ” dans toutes les collections telles que les listes, les ensembles, les chaînes et les tuples.
La vérification de l'appartenance est illustrée dans l'extrait de code suivant (voir Figure 1 ):
>>> item = 42 >>> my_list = [1, 2, 3, 4, 5, 6] >>> item not in my_list True
Voici un autre exemple sur les chaînes qui montre que la capitalisation est importante pour l'égalité des chaînes Python :
x = 'alice' my_list = ['Alice', 'Bob', 'Carl'] print(x not 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 Python "pas dans"
Vous pouvez vérifier l'appartenance négative d'un personnage dans une chaîne en utilisant le "not in ” opérateur de mot-clé. Par exemple, l'expression 'f' not in 'finxter' renvoie False car le caractère 'f' existe dans la chaîne 'finxter' .
>>> 'f' not in 'finxter' False
Vous pouvez également vérifier l'appartenance négative d'une chaîne dans une autre chaîne en utilisant le "not in ” opérateur. Par exemple, l'expression 'inx' not in 'finxter' renvoie False car la chaîne 'inx' existe dans la chaîne 'finxter' .
>>> 'inx' not in 'finxter' False
Liste Python "pas dans"
Vous pouvez vérifier l'appartenance négative d'un objet individuel dans une liste en utilisant le "not in ” opérateur de mot-clé. Par exemple, l'expression 42 not in [1, 2, 3] renvoie True car l'entier 42 n'existe pas dans la liste [1, 2, 3]
>>> 42 not in [1, 2, 3] True >>> 'finxter' not in ['finxter', 'learn', 'python'] False
Ensemble "pas dans" Python
Vous pouvez vérifier l'appartenance négative d'un objet individuel dans un ensemble avec le "not in ” opérateur de mot-clé. Par exemple, l'expression 42 not in {1, 2, 3} renvoie True car l'entier 42 n'existe pas dans l'ensemble {1, 2, 3}
>>> 42 not in {1, 2, 3}
True
>>> 'finxter' not in {'finxter', 'learn', 'python'}
False Dictionnaire Python "pas dans"
Vous pouvez vérifier l'appartenance négative d'une clé individuelle dans un dictionnaire avec le "not in ” opérateur de mot-clé. Par exemple, l'expression 'a' not in {'a': 1, 'b': 2} renvoie False car la clé de chaîne existe dans le dictionnaire.
>>> 'a' not in {'a': 1, 'b': 2}
False
>>> 'c' not in {'a': 1, 'b': 2}
True
>>> 43 not in {42: [1, 2], 22: [3, 4]}
True Python "pas dans" la plage
Vous pouvez vérifier l'appartenance négative d'une clé individuelle dans un objet range avec le "not in ” opérateur de mot-clé. Par exemple, l'expression 5 not in range(5) renvoie True car l'entier 4 n'existe pas dans l'objet range avec les entiers 0, 1, 2, 3, 4.
>>> 5 not in range(5) True >>> 4 not in range(5) False
Surcharge d'opérateur Python "pas dans"
La surcharge d'opérateur remplace la signification standard d'un opérateur par une version personnalisée. Vous pouvez surcharger le "in ” et “not in ” opérateurs 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' not in my)
# False
print('hi' not 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é.
? Remarque :En remplaçant la méthode magique __contains__(self, item) , votre classe Python prend désormais en charge l'appartenance positive et négative avec les opérateurs "in ” et “not in “.
Complexité d'exécution de l'opérateur Python "pas dans"
Le tableau suivant montre les complexités d'exécution du "not 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 positive et négative pour les listes, les tuples et les 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.
