L'opérateur not en Python : négation logique expliquée

Définition de l'opérateur not en Python

L'opérateur not est l'un des trois opérateurs logiques (ou booléens) de Python, aux côtés de and et or. Son rôle est simple mais fondamental : il inverse la valeur de vérité d'une expression. Si une expression est évaluée comme True, not la transforme en False, et inversement.

En programmation, la négation logique est utilisée en permanence : vérifier qu'une condition n'est pas remplie, inverser un drapeau booléen, filtrer des éléments qui ne correspondent pas à un critère, etc. Si vous souhaitez approfondir vos compétences en Python et maîtriser tous ses opérateurs, notre formation complète sur Python vous guidera pas à pas.

Contrairement aux opérateurs arithmétiques ou de comparaison, not est un opérateur unaire : il ne s'applique qu'à une seule valeur, celle qui le suit immédiatement.

Syntaxe et fonctionnement de base

La syntaxe de not est d'une grande simplicité :

not expression

L'opérateur évalue d'abord l'expression qui le suit, puis retourne la valeur booléenne inverse. Voyons cela avec les cas les plus élémentaires :

print(not True)   # False
print(not False)  # True

C'est le comportement fondamental : not True donne False et not False donne True. Voici la table de vérité complète de l'opérateur not :

C'est aussi simple que cela. Mais la véritable puissance de not apparaît lorsqu'il est combiné avec des expressions plus complexes et le concept de valeurs truthy et falsy.

Valeurs truthy et falsy avec not

En Python, chaque objet possède une valeur de vérité implicite. On parle de valeurs truthy (évaluées comme True) et falsy (évaluées comme False). L'opérateur not se base sur cette évaluation implicite pour fonctionner.

Les valeurs falsy en Python

Les valeurs suivantes sont considérées comme falsy, c'est-à-dire qu'elles sont évaluées comme False dans un contexte booléen :

Vérifions cela avec un exemple concret :

# Toutes ces expressions retournent True
print(not None)    # True
print(not 0)       # True
print(not 0.0)     # True
print(not "")      # True
print(not [])      # True
print(not ())      # True
print(not {})      # True

Les valeurs truthy

À l'inverse, toute valeur qui n'est pas falsy est truthy. Appliquer not sur une valeur truthy retourne False :

print(not 42)           # False
print(not "Bonjour")    # False
print(not [1, 2, 3])    # False
print(not {"clé": "val"})  # False

Cette mécanique est extrêmement utile pour vérifier rapidement si une collection est vide, si une variable est définie, ou si une valeur numérique est non nulle.

Exemples pratiques d'utilisation

Voyons maintenant comment not est utilisé dans des situations réelles de développement Python.

Vérifier qu'une liste est vide

L'un des usages les plus courants de not est de vérifier si une collection (list, dict, sets, etc.) est vide :

panier = []

if not panier:
    print("Votre panier est vide.")
else:
    print(f"Vous avez {len(panier)} article(s).")

# Résultat : Votre panier est vide.

Cette approche est considérée comme pythonique. Elle est préférée à if len(panier) == 0: car elle est plus lisible et plus idiomatique.

Vérifier qu'une variable n'est pas None

utilisateur = None

if not utilisateur:
    print("Aucun utilisateur connecté.")
    # Rediriger vers la page de connexion
else:
    print(f"Bienvenue, {utilisateur} !")

Inverser une condition dans une boucle

nombres = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# Filtrer les nombres qui ne sont PAS pairs
nombres_impairs = [n for n in nombres if not n % 2 == 0]
print(nombres_impairs)  # [1, 3, 5, 7, 9]

Dans cet exemple, not n % 2 == 0 inverse la condition "est pair" pour ne garder que les nombres impairs. Vous pourriez aussi écrire n % 2 != 0, mais l'usage de not est parfois plus lisible pour des conditions complexes.

Combiner not avec and et or

L'opérateur not peut être combiné avec les opérateurs and et or pour construire des conditions logiques complexes :

age = 25
est_etudiant = False
est_membre = True

# Accès gratuit si membre OU si étudiant de moins de 26 ans
# Mais PAS si les deux conditions sont fausses
if est_membre or (est_etudiant and age < 26):
    print("Accès gratuit")
else:
    print("Accès payant")

# Vérifier qu'un utilisateur n'est PAS étudiant ET n'est PAS membre
if not est_etudiant and not est_membre:
    print("Aucun avantage disponible")
else:
    print("Vous bénéficiez d'avantages")

Utilisation avec not in

La combinaison not in est un opérateur de test d'appartenance qui vérifie qu'un élément n'est pas présent dans une séquence :

fruits_autorises = ["pomme", "banane", "orange", "kiwi"]
fruit_choisi = "mangue"

if fruit_choisi not in fruits_autorises:
    print(f"Désolé, {fruit_choisi} n'est pas disponible.")
else:
    print(f"Excellent choix : {fruit_choisi} !")

# Résultat : Désolé, mangue n'est pas disponible.

Utilisation avec is not

De la même manière, is not permet de vérifier qu'un objet n'est pas un objet spécifique (comparaison d'identité) :

resultat = None

# Vérifier que le résultat a bien été défini
if resultat is not None:
    print(f"Le résultat est : {resultat}")
else:
    print("Aucun résultat disponible.")

Priorité de l'opérateur not

Il est essentiel de comprendre la priorité (ou précédence) de not par rapport aux autres opérateurs. Voici l'ordre de priorité des opérateurs logiques en Python, du plus prioritaire au moins prioritaire :

Cela signifie que not est évalué avant and, qui est lui-même évalué avant or. Voyons un exemple :

a = True
b = False
c = True

# not est évalué en premier
resultat = not a or b and c
# Équivalent à : (not a) or (b and c)
# = False or (False and True)
# = False or False
# = False
print(resultat)  # False

Attention également à la priorité de not par rapport aux opérateurs de comparaison :

x = 5

# not s'applique APRÈS la comparaison
print(not x == 5)   # not (x == 5) → not True → False

# Ce n'est PAS la même chose que
print((not x) == 5) # (not 5) == 5 → False == 5 → False

Les opérateurs de comparaison (==, !=, <, >, etc.) ont une priorité plus élevée que not. Mais not a une priorité plus basse que les opérateurs arithmétiques. Cela peut être source de confusion, d'où l'importance des parenthèses.

Le double not (not not)

Vous rencontrerez parfois l'expression not not dans du code Python. Il s'agit d'une technique pour convertir explicitement une valeur en son équivalent booléen :

valeur = 42

print(not not valeur)  # True
print(bool(valeur))    # True (équivalent plus lisible)

valeur_vide = ""

print(not not valeur_vide)  # False
print(bool(valeur_vide))    # False (équivalent plus lisible)

Bien que not not fonctionne, il est recommandé d'utiliser la fonction bool() qui est beaucoup plus explicite et lisible. Le double not est considéré comme un anti-pattern en Python.

Personnaliser le comportement de not avec __bool__

Lorsque vous créez vos propres class, vous pouvez contrôler le comportement de not en définissant les méthodes spéciales __bool__ ou __len__ :

class Inventaire:
    def __init__(self, articles=None):
        self.articles = articles or []
    
    def __bool__(self):
        return len(self.articles) > 0
    
    def __repr__(self):
        return f"Inventaire({self.articles})"


# Un inventaire vide est falsy
inventaire_vide = Inventaire()
print(not inventaire_vide)  # True

if not inventaire_vide:
    print("L'inventaire est vide, commandez du stock !")

# Un inventaire rempli est truthy
inventaire_plein = Inventaire(["clavier", "souris", "écran"])
print(not inventaire_plein)  # False

if not inventaire_plein:
    print("L'inventaire est vide.")
else:
    print(f"L'inventaire contient {len(inventaire_plein.articles)} articles.")

Bonnes pratiques avec l'opérateur not

Voici les règles essentielles à suivre pour utiliser not de manière efficace et pythonique :

1. Préférez les formes idiomatiques

# ✅ Bon - Pythonique
if not ma_liste:
    print("Liste vide")

# ❌ Moins bon - Non pythonique
if len(ma_liste) == 0:
    print("Liste vide")

2. Utilisez is not et not in plutôt que not ... is et not ... in

# ✅ Bon - Recommandé par PEP 8
if x is not None:
    pass

if element not in collection:
    pass

# ❌ Moins bon - Déconseillé
if not x is None:
    pass

if not element in collection:
    pass

3. Évitez les doubles négations inutiles

# ✅ Bon
if condition:
    pass

# ❌ Mauvais - Double négation confuse
if not not condition:
    pass

4. Simplifiez les expressions avec not

# ✅ Bon - Direct et clair
if not est_valide:
    raise ValueError("Donnée invalide")

# ❌ Moins bon - Comparaison superflue
if est_valide == False:
    raise ValueError("Donnée invalide")

# ❌ Encore pire
if not est_valide == True:
    raise ValueError("Donnée invalide")

5. Utilisez des parenthèses pour les expressions complexes

# ✅ Bon - Clair grâce aux parenthèses
if not (age >= 18 and a_permis):
    print("Vous ne pouvez pas conduire.")

# ❌ Ambigu sans parenthèses
if not age >= 18 and a_permis:
    print("Comportement inattendu possible")

Les lois de De Morgan avec not

Les lois de De Morgan sont un concept mathématique essentiel pour simplifier les expressions logiques. Elles s'appliquent directement en Python :

# Loi de De Morgan 1 :
# not (A and B) == (not A) or (not B)

A = True
B = False

print(not (A and B))           # True
print((not A) or (not B))      # True (identique)

# Loi de De Morgan 2 :
# not (A or B) == (not A) and (not B)

print(not (A or B))            # False
print((not A) and (not B))     # False (identique)

Ces lois sont très utiles pour réécrire des conditions complexes de manière plus lisible :

# Ces deux écritures sont équivalentes
if not (est_admin or est_moderateur):
    print("Accès refusé")

if not est_admin and not est_moderateur:
    print("Accès refusé")

Choisissez la forme qui rend votre intention la plus claire selon le contexte.

Questions fréquentes

not est un opérateur de négation logique qui inverse une valeur booléenne (not True donne False). != est un opérateur de comparaison qui vérifie si deux valeurs sont différentes (5 != 3 donne True). is not vérifie que deux variables ne pointent pas vers le même objet en mémoire (a is not b). Chacun a un rôle distinct : not inverse, != compare les valeurs, et is not compare les identités.

En Python, une list vide ([]) est considérée comme une valeur falsy, c'est-à-dire qu'elle est évaluée comme False dans un contexte booléen. L'opérateur not inverse cette valeur, ce qui donne True. C'est le même principe pour toutes les collections vides : dict vide ({}), tuple vide (()), sets vide (set()), chaîne vide (""), et la valeur None.

Oui, absolument. Vous pouvez utiliser not dans une fonction lambda comme dans n'importe quelle expression Python. Par exemple : est_impair = lambda n: not n % 2 == 0. C'est particulièrement utile avec des fonctions comme filter() : list(filter(lambda x: not x.startswith("_"), noms)) pour filtrer les éléments qui ne commencent pas par un underscore.

Pour maîtriser not et les autres opérateurs logiques de Python, la pratique régulière est indispensable. Commencez par écrire de petites conditions, puis construisez progressivement des expressions plus complexes en combinant not, and et or. Pour un apprentissage structuré et complet, notre formation dédiée à Python vous permettra de comprendre en profondeur tous les opérateurs et mécanismes du langage, avec des exercices pratiques à chaque étape.