L'opérateur or en Python : guide complet avec exemples

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

L'opérateur or est un opérateur logique booléen en Python qui permet de combiner deux expressions conditionnelles. Il retourne True si au moins une des deux expressions est vraie. C'est l'un des trois opérateurs logiques fondamentaux du langage, aux côtés de and et not.

Si vous souhaitez maîtriser Python en profondeur, y compris ses opérateurs logiques et toutes ses subtilités, notre formation complète sur Python vous accompagnera pas à pas dans votre apprentissage.

La syntaxe de base est la suivante :

expression1 or expression2

Python évalue d'abord expression1. Si elle est considérée comme vraie (truthy), il retourne immédiatement sa valeur sans même évaluer expression2. Si expression1 est fausse (falsy), Python évalue et retourne la valeur de expression2. Ce mécanisme s'appelle l'évaluation paresseuse (ou short-circuit evaluation en anglais).

Voici la table de vérité de l'opérateur or :

Comprendre les valeurs truthy et falsy

Pour bien utiliser or, il est essentiel de comprendre ce que Python considère comme vrai (truthy) ou faux (falsy). En Python, les valeurs suivantes sont considérées comme falsy :

• False
• None
• 0 (zéro entier)
• 0.0 (zéro flottant)
• "" (chaîne vide)
• [] (list vide)
• () (tuple vide)
• {} (dict vide)
• set() (sets vide)

Toutes les autres valeurs sont considérées comme truthy. Cela signifie que l'opérateur or fonctionne bien au-delà des simples booléens :

# Avec des booléens
print(True or False)    # True
print(False or True)    # True
print(False or False)   # False

# Avec d'autres types
print(0 or 42)          # 42
print("" or "Bonjour")  # Bonjour
print(None or "valeur") # valeur
print([] or [1, 2, 3])  # [1, 2, 3]

Comme vous pouvez le constater, l'opérateur or retourne la première valeur truthy rencontrée, ou la dernière valeur si toutes sont falsy :

# Retourne la première valeur truthy
print(0 or "" or None or "Python")  # Python
print("Premier" or "Second")        # Premier

# Toutes les valeurs sont falsy : retourne la dernière
print(0 or "" or None or [])        # []
print(False or 0)                   # 0

Exemples pratiques de l'opérateur or

Utilisation dans les conditions if

L'usage le plus courant de or se trouve dans les structures conditionnelles, où vous souhaitez vérifier si au moins une condition est remplie :

age = 15
est_accompagne = True

if age >= 18 or est_accompagne:
    print("Accès autorisé")
else:
    print("Accès refusé")

# Résultat : Accès autorisé (car est_accompagne est True)

Vous pouvez combiner plusieurs conditions avec or :

jour = "samedi"

if jour == "samedi" or jour == "dimanche" or jour == "mercredi":
    print("Jour de repos possible")
else:
    print("Jour de travail")

Valeurs par défaut avec or

Une utilisation très courante et élégante de or en Python consiste à définir des valeurs par défaut :

def saluer(nom=None):
    nom = nom or "Visiteur"
    print(f"Bonjour, {nom} !")

saluer("Alice")   # Bonjour, Alice !
saluer("")        # Bonjour, Visiteur !
saluer(None)      # Bonjour, Visiteur !
saluer()          # Bonjour, Visiteur !

Ce motif est extrêmement pratique pour les paramètres de def qui peuvent être None ou vides. Cependant, soyez vigilant : si 0 ou False sont des valeurs légitimes, ce motif les remplacera aussi :

def configurer_port(port=None):
    # Attention : port = 0 serait remplacé par 8080 !
    port = port or 8080
    print(f"Écoute sur le port {port}")

configurer_port(3000)  # Écoute sur le port 3000
configurer_port(0)     # Écoute sur le port 8080 (problème potentiel !)
configurer_port(None)  # Écoute sur le port 8080

Chaînage de or pour sélectionner la première valeur disponible

Vous pouvez chaîner plusieurs or pour sélectionner la première valeur non vide parmi plusieurs sources :

import os

# Chercher une configuration dans plusieurs sources
nom_utilisateur = (
    os.environ.get("USER_NAME")
    or os.environ.get("USERNAME")
    or os.environ.get("LOGNAME")
    or "utilisateur_inconnu"
)

print(f"Utilisateur : {nom_utilisateur}")

Ce patron est particulièrement utile dans la gestion de configuration où vous souhaitez vérifier plusieurs sources de données avant d'utiliser une valeur par défaut.

Combinaison avec and et not

L'opérateur or peut être combiné avec les autres opérateurs logiques pour créer des conditions complexes. Il est important de connaître l'ordre de priorité :

Cela signifie que and est évalué avant or :

# Sans parenthèses
resultat = True or False and False
print(resultat)  # True
# Équivalent à : True or (False and False) → True or False → True

# Avec parenthèses pour changer l'ordre
resultat = (True or False) and False
print(resultat)  # False
# (True or False) → True, puis True and False → False

Voici un exemple concret combinant les trois opérateurs :

est_admin = False
est_moderateur = True
est_banni = False

if (est_admin or est_moderateur) and not est_banni:
    print("Accès au panneau de modération")
else:
    print("Accès refusé")

# Résultat : Accès au panneau de modération

L'évaluation paresseuse en détail

L'évaluation paresseuse (short-circuit evaluation) de or peut avoir des implications importantes, notamment quand les expressions ont des effets de bord :

def verifier_base():
    print("Vérification en base de données...")
    return True

def verifier_cache():
    print("Vérification dans le cache...")
    return True

# Si le cache retourne True, la base n'est jamais interrogée
resultat = verifier_cache() or verifier_base()
# Affiche uniquement : Vérification dans le cache...

Ce comportement est utile pour optimiser les performances. Vous pouvez placer les vérifications les moins coûteuses en premier :

def est_dans_cache(cle):
    """Vérification rapide en mémoire"""
    return cache.get(cle)

def est_dans_base(cle):
    """Requête lente vers la base de données"""
    return db.query(cle)

# La base n'est consultée que si le cache ne contient pas la clé
resultat = est_dans_cache("user_123") or est_dans_base("user_123")

L'évaluation paresseuse est aussi utile pour éviter des erreurs :

donnees = None

# Sans évaluation paresseuse, donnees.get() provoquerait une erreur
valeur = donnees or {}
resultat = valeur.get("cle", "défaut")
print(resultat)  # défaut

Utilisation avec les compréhensions et les fonctions

L'opérateur or s'intègre naturellement dans les list en compréhension et avec des fonctions comme lambda :

# Filtrer avec or dans une compréhension de liste
nombres = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
filtres = [n for n in nombres if n < 3 or n > 8]
print(filtres)  # [1, 2, 9, 10]

# Avec une fonction lambda
valider = lambda x: x or "Non spécifié"
print(valider("Alice"))  # Alice
print(valider(""))       # Non spécifié
print(valider(None))     # Non spécifié

Vous pouvez aussi utiliser or dans la fonction print pour afficher des valeurs par défaut :

nom = ""
print(nom or "Anonyme")  # Anonyme

resultat = None
print(f"Résultat : {resultat or 'Aucun résultat'}")  # Résultat : Aucun résultat

Utilisation avec any() pour des collections

Quand vous devez vérifier si au moins un élément d'une collection satisfait une condition, la fonction intégrée any() est l'équivalent de multiples or enchaînés :

notes = [12, 8, 15, 6, 18]

# Avec or (peu pratique pour une liste)
a_une_bonne_note = notes[0] >= 16 or notes[1] >= 16 or notes[2] >= 16

# Avec any() (élégant et flexible)
a_une_bonne_note = any(note >= 16 for note in notes)
print(a_une_bonne_note)  # True (grâce au 18)

# any() utilise aussi l'évaluation paresseuse
# Elle s'arrête dès qu'une valeur True est trouvée

Bonnes pratiques

Voici les recommandations essentielles pour utiliser or efficacement en Python :

• Utilisez des parenthèses quand vous combinez or avec and pour rendre l'intention explicite.
• Privilégiez in plutôt que de multiples or pour tester l'appartenance : x in ("a", "b", "c") plutôt que x == "a" or x == "b" or x == "c".
• Placez les conditions les moins coûteuses en premier pour tirer parti de l'évaluation paresseuse.
• Faites attention avec les valeurs par défaut : x or valeur_defaut remplace aussi 0, False et "". Utilisez x if x is not None else valeur_defaut si nécessaire.
• Utilisez any() quand vous avez un nombre variable de conditions OU logiques à vérifier.
• Évitez les expressions trop longues : si une condition avec or dépasse 3-4 termes, envisagez de la découper en variables intermédiaires pour améliorer la lisibilité.

# ❌ Difficile à lire
if user.age >= 18 or user.has_permission or user.is_admin or user.is_moderator or user.parent_approved:
    grant_access()

# ✅ Plus lisible avec des variables intermédiaires
est_majeur = user.age >= 18
a_les_droits = user.has_permission or user.is_admin or user.is_moderator
est_autorise_parent = user.parent_approved

if est_majeur or a_les_droits or est_autorise_parent:
    grant_access()

# ✅ Encore plus lisible avec any()
conditions = [
    user.age >= 18,
    user.has_permission,
    user.is_admin,
    user.is_moderator,
    user.parent_approved,
]
if any(conditions):
    grant_access()

Questions fréquentes

L'opérateur or est un opérateur logique qui fonctionne avec l'évaluation paresseuse et retourne l'une des deux valeurs opérandes. L'opérateur | est un opérateur binaire (bitwise) qui effectue un OU bit à bit sur des entiers. Depuis Python 3.9, | peut aussi être utilisé pour fusionner des dict. En règle générale, utilisez or pour les conditions logiques et | pour les opérations sur les bits ou la fusion de dictionnaires.

C'est un choix de conception de Python qui privilégie la praticité. En retournant la valeur réelle de l'opérande (et non son équivalent booléen), or permet des motifs élégants comme les valeurs par défaut (nom or "Anonyme"). Si vous avez besoin d'un booléen strict, vous pouvez envelopper l'expression avec bool() : bool(expression1 or expression2).

Oui, absolument. L'opérateur or peut être utilisé dans n'importe quelle expression Python, y compris les lambda. Par exemple : nettoyer = lambda x: x.strip() or "vide". C'est un moyen concis de créer des fonctions qui retournent des valeurs par défaut.

La meilleure façon de maîtriser or et les autres opérateurs logiques est de pratiquer avec des projets concrets. Nous vous recommandons de suivre notre formation Python complète sur Believemy, qui couvre en détail les opérateurs logiques, les structures conditionnelles et toutes les subtilités du langage à travers des exercices pratiques et des projets réels.