[OK] CHEATSHEET COMPLET - CONDITIONS ET STRUCTURES DE CONTRÔLE PYTHON


[OK] 1. IF - CONDITION BASIQUE
[OK] Exécute du code si une condition est vraie
age = 18

if age >= 18:
    print("Vous êtes majeur")  # S'exécute si age >= 18

# Sans bloc else
score = 85
if score >= 90:
    print("Excellent!")

# Condition simple sur une ligne
if age >= 18: print("Majeur")


[OK] 2. IF-ELSE - ALTERNATIVE
[OK] Exécute un bloc si vrai, un autre si faux
age = 16

if age >= 18:
    print("Vous êtes majeur")
else:
    print("Vous êtes mineur")  # S'exécute car age < 18

# Exemple avec calcul
temperature = 25

if temperature > 30:
    print("Il fait chaud")
else:
    print("Il fait bon")


[OK] 3. IF-ELIF-ELSE - MULTIPLES CONDITIONS
[OK] Teste plusieurs conditions dans l'ordre
note = 75

if note >= 90:
    print("A - Excellent")
elif note >= 80:
    print("B - Très bien")
elif note >= 70:
    print("C - Bien")  # S'exécute ici
elif note >= 60:
    print("D - Passable")
else:
    print("F - Échec")

# Exemple pratique: menu
choix = 2

if choix == 1:
    print("Nouveau fichier")
elif choix == 2:
    print("Ouvrir fichier")
elif choix == 3:
    print("Enregistrer")
else:
    print("Option invalide")


[OK] 4. CONDITIONS IMBRIQUÉES (NESTED IF)
[OK] Une condition à l'intérieur d'une autre
age = 25
permis = True

if age >= 18:
    if permis:
        print("Vous pouvez conduire")  # S'exécute
    else:
        print("Vous devez passer le permis")
else:
    print("Trop jeune pour conduire")

# Exemple avec plusieurs niveaux
score = 85
bonus = 10

if score >= 80:
    if bonus > 5:
        total = score + bonus
        if total >= 90:
            print("A avec bonus")
        else:
            print("B avec bonus")
    else:
        print("B sans bonus suffisant")


[OK] 5. OPÉRATEURS DE COMPARAISON
[OK] Utilisés dans les conditions pour comparer des valeurs
a = 10
b = 20

# Égalité
if a == b:
    print("Égaux")

# Différent
if a != b:
    print("Différents")  # S'exécute

# Supérieur / Inférieur
if b > a:
    print("b est plus grand")  # S'exécute

if a < b:
    print("a est plus petit")  # S'exécute

# Supérieur ou égal / Inférieur ou égal
if a >= 10:
    print("a est supérieur ou égal à 10")  # S'exécute

if b <= 20:
    print("b est inférieur ou égal à 20")  # S'exécute

# Comparaison de strings
mot1 = "apple"
mot2 = "banana"

if mot1 < mot2:  # Ordre alphabétique
    print("apple vient avant banana")


[OK] 6. OPÉRATEURS LOGIQUES
[OK] Combinent plusieurs conditions

# AND - Les deux conditions doivent être vraies
age = 25
permis = True

if age >= 18 and permis:
    print("Peut conduire")  # S'exécute

if age >= 18 and not permis:
    print("Doit passer le permis")

# OR - Au moins une condition doit être vraie
jour = "samedi"

if jour == "samedi" or jour == "dimanche":
    print("C'est le weekend!")  # S'exécute

# NOT - Inverse la condition
pluie = False

if not pluie:
    print("Pas de pluie")  # S'exécute

# Combinaisons complexes
age = 25
permis = True
assurance = True

if (age >= 18 and permis) and assurance:
    print("Peut louer une voiture")

# Priorité: not > and > or
x = True
y = False
z = True

if not x or y and z:  # Équivaut à: (not x) or (y and z)
    print("Condition vraie")


[OK] 7. OPÉRATEURS D'APPARTENANCE
[OK] Vérifient si une valeur est dans une séquence

# IN - Vérifie la présence
fruits = ["pomme", "banane", "orange"]

if "pomme" in fruits:
    print("Pomme disponible")  # S'exécute

# NOT IN - Vérifie l'absence
if "kiwi" not in fruits:
    print("Kiwi non disponible")  # S'exécute

# Avec strings
texte = "Hello World"

if "World" in texte:
    print("Trouvé")  # S'exécute

# Avec dictionnaires (vérifie les clés)
user = {"name": "Alice", "age": 30}

if "name" in user:
    print(f"Nom: {user['name']}")

# Avec tuples et sets
nombres = (1, 2, 3, 4, 5)
if 3 in nombres:
    print("3 est dans le tuple")


[OK] 8. OPÉRATEURS D'IDENTITÉ
[OK] Comparent l'identité des objets (même emplacement mémoire)

# IS - Même objet
a = [1, 2, 3]
b = a  # b pointe vers le même objet que a
c = [1, 2, 3]  # c est un nouvel objet

if a is b:
    print("a et b sont le même objet")  # S'exécute

if a is not c:
    print("a et c sont différents objets")  # S'exécute

# == vs is
if a == c:
    print("a et c ont la même valeur")  # S'exécute

# Cas spéciaux: None, True, False
valeur = None

if valeur is None:  # Préféré à == None
    print("Valeur est None")

# Attention avec les petits entiers et strings (interning)
x = 256
y = 256
print(x is y)  # True (Python cache les petits entiers)

x = 257
y = 257
print(x is y)  # False (au-delà du cache)


[OK] 9. VALEURS TRUTHINESS (VRAIES/FAUSSES)
[OK] Toute valeur peut être évaluée en booléen

# Valeurs FAUSSES (Falsy):
# - False, None, 0, 0.0, '', [], {}, (), set()

# Exemples de valeurs fausses
if not 0:
    print("0 est faux")

if not "":
    print("String vide est fausse")

if not []:
    print("Liste vide est fausse")

if not None:
    print("None est faux")

# Valeurs VRAIES (Truthy): tout le reste
if "texte":
    print("String non vide est vraie")

if [1, 2]:
    print("Liste non vide est vraie")

if 42:
    print("Nombre non-zéro est vrai")

# Utilisation pratique
nom = input("Nom: ")

if nom:  # Vérifie si nom n'est pas vide
    print(f"Bonjour {nom}")
else:
    print("Nom requis")

# Vérifier une liste
items = []

if items:
    print("Liste contient des éléments")
else:
    print("Liste vide")


[OK] 10. EXPRESSION CONDITIONNELLE (TERNAIRE)
[OK] If-else sur une seule ligne: valeur_si_vrai if condition else valeur_si_faux

age = 20

# Forme classique
if age >= 18:
    statut = "Majeur"
else:
    statut = "Mineur"

# Forme ternaire (condensée)
statut = "Majeur" if age >= 18 else "Mineur"
print(statut)  # "Majeur"

# Exemples pratiques
note = 85
resultat = "Réussi" if note >= 60 else "Échoué"

prix = 100
remise = prix * 0.9 if prix > 50 else prix

nombre = -5
valeur_abs = nombre if nombre >= 0 else -nombre

# Ternaire imbriqué (moins lisible, à éviter)
score = 75
grade = "A" if score >= 90 else "B" if score >= 80 else "C"

# Dans des fonctions
def get_discount(total):
    return total * 0.2 if total > 100 else total * 0.1

# Dans les print
age = 16
print("Adulte" if age >= 18 else "Enfant")


[OK] 11. MATCH-CASE (Python 3.10+)
[OK] Pattern matching - alternative moderne au if-elif-else

# Syntaxe basique
statut = 404

match statut:
    case 200:
        print("OK")
    case 404:
        print("Page non trouvée")  # S'exécute
    case 500:
        print("Erreur serveur")
    case _:  # Cas par défaut (comme else)
        print("Statut inconnu")

# Avec plusieurs valeurs
jour = "samedi"

match jour:
    case "lundi" | "mardi" | "mercredi" | "jeudi" | "vendredi":
        print("Jour de semaine")
    case "samedi" | "dimanche":
        print("Weekend")  # S'exécute
    case _:
        print("Jour invalide")

# Pattern matching avec structures
point = (0, 5)

match point:
    case (0, 0):
        print("Origine")
    case (0, y):
        print(f"Sur l'axe Y: {y}")  # S'exécute, y=5
    case (x, 0):
        print(f"Sur l'axe X: {x}")
    case (x, y):
        print(f"Point quelconque: ({x}, {y})")

# Avec dictionnaires
user = {"name": "Alice", "role": "admin"}

match user:
    case {"role": "admin", "name": name}:
        print(f"Admin: {name}")  # S'exécute
    case {"role": "user"}:
        print("Utilisateur normal")

# Avec classes
class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

p = Point(0, 5)

match p:
    case Point(x=0, y=0):
        print("Origine")
    case Point(x=0, y=y):
        print(f"Sur Y: {y}")  # S'exécute
    case Point(x=x, y=y):
        print(f"Point: ({x}, {y})")

# Avec garde (if additionnel)
nombres = [1, 2, 3]

match nombres:
    case [x, y] if x == y:
        print("Deux éléments identiques")
    case [x, y, z] if x + y == z:
        print("La somme des deux premiers égale le troisième")
    case _:
        print("Autre cas")


[OK] 12. SHORT-CIRCUIT EVALUATION
[OK] Les opérateurs logiques s'arrêtent dès que le résultat est connu

# AND: s'arrête au premier False
def check_a():
    print("Vérifie A")
    return False

def check_b():
    print("Vérifie B")
    return True

# check_b() n'est jamais appelé car check_a() retourne False
if check_a() and check_b():
    print("Les deux sont vrais")
# Affiche seulement: "Vérifie A"

# OR: s'arrête au premier True
def check_c():
    print("Vérifie C")
    return True

def check_d():
    print("Vérifie D")
    return False

# check_d() n'est jamais appelé car check_c() retourne True
if check_c() or check_d():
    print("Au moins un est vrai")
# Affiche: "Vérifie C" puis "Au moins un est vrai"

# Utilisation pratique: éviter les erreurs
user = None

# [X] Erreur si user est None
# if user.name == "Alice":

# [OK] Safe: vérifie d'abord que user existe
if user and user.name == "Alice":
    print("User est Alice")

# Vérifier l'existence avant d'accéder
liste = []

if liste and liste[0] > 10:  # Ne cause pas d'erreur sur liste vide
    print("Premier élément > 10")

# Valeur par défaut avec or
nom = ""
nom_affiche = nom or "Anonyme"  # "Anonyme" car nom est vide
print(nom_affiche)


[OK] 13. ASSERTIONS
[OK] Vérifient qu'une condition est vraie, sinon lèvent une erreur

# Syntaxe basique
age = 25
assert age >= 18  # Passe sans problème

# Avec message d'erreur
prix = -10
# assert prix > 0, "Le prix doit être positif"  # AssertionError

# Utilisation pour le débogage
def calculer_moyenne(notes):
    assert len(notes) > 0, "La liste de notes ne peut pas être vide"
    assert all(0 <= note <= 100 for note in notes), "Notes doivent être entre 0 et 100"
    return sum(notes) / len(notes)

# Exemples pratiques
def diviser(a, b):
    assert b != 0, "Division par zéro impossible"
    return a / b

def withdraw(solde, montant):
    assert montant > 0, "Montant doit être positif"
    assert montant <= solde, "Fonds insuffisants"
    return solde - montant

# [ATTENTION] Note: assert est désactivé avec python -O (optimisation)
# Ne PAS utiliser assert pour valider des entrées utilisateur
# Utiliser des if avec raise Exception pour cela


[OK] 14. GESTION D'EXCEPTIONS AVEC CONDITIONS
[OK] Combine try-except avec des conditions

# Validation avec conditions puis exceptions
def creer_utilisateur(age, email):
    # Validation avec conditions
    if not email or '@' not in email:
        raise ValueError("Email invalide")
    
    if age < 0:
        raise ValueError("Âge ne peut pas être négatif")
    
    if age < 18:
        raise ValueError("Doit être majeur")
    
    return {"age": age, "email": email}

# Utilisation
try:
    user = creer_utilisateur(16, "test@example.com")
except ValueError as e:
    print(f"Erreur: {e}")  # "Erreur: Doit être majeur"

# Conditions dans le bloc except
def traiter_fichier(nom_fichier):
    try:
        with open(nom_fichier, 'r') as f:
            contenu = f.read()
    except FileNotFoundError:
        if nom_fichier.endswith('.txt'):
            print("Fichier texte non trouvé")
        else:
            print("Fichier non trouvé")
    except PermissionError:
        print("Pas de permission pour lire le fichier")


[OK] 15. GUARD CLAUSES (CLAUSES DE GARDE)
[OK] Sortir tôt d'une fonction pour éviter l'imbrication

# [X] Mauvais: trop d'imbrication
def process_user_bad(user):
    if user is not None:
        if user.get('active'):
            if user.get('age', 0) >= 18:
                if user.get('verified'):
                    # Code principal ici
                    return "Utilisateur traité"
                else:
                    return "Non vérifié"
            else:
                return "Trop jeune"
        else:
            return "Inactif"
    else:
        return "Utilisateur invalide"

# [OK] Bon: guard clauses - sortir tôt
def process_user_good(user):
    # Vérifications en début, sortie anticipée
    if user is None:
        return "Utilisateur invalide"
    
    if not user.get('active'):
        return "Inactif"
    
    if user.get('age', 0) < 18:
        return "Trop jeune"
    
    if not user.get('verified'):
        return "Non vérifié"
    
    # Code principal, pas d'imbrication
    return "Utilisateur traité"

# Autre exemple
def calculer_remise(prix, client):
    # Guards
    if prix <= 0:
        return 0
    
    if client is None:
        return 0
    
    if not client.get('est_membre'):
        return prix * 0.05  # 5% pour non-membres
    
    # Membre: logique principale
    annees = client.get('annees_membre', 0)
    if annees > 5:
        return prix * 0.20
    elif annees > 2:
        return prix * 0.15
    else:
        return prix * 0.10


[OK] 16. CONDITIONS AVEC WALRUS OPERATOR := (Python 3.8+)
[OK] Assigne et teste une valeur dans la même expression

# Sans walrus (deux lignes)
texte = input("Entrez du texte: ")
if len(texte) > 10:
    print(f"Texte long: {len(texte)} caractères")

# Avec walrus (une ligne)
if (longueur := len(input("Entrez du texte: "))) > 10:
    print(f"Texte long: {longueur} caractères")

# Exemple pratique: traitement de fichiers
import re

# Sans walrus
data = get_data()
match = re.search(r'(\d+)', data)
if match:
    nombre = match.group(1)
    print(nombre)

# Avec walrus
if match := re.search(r'(\d+)', get_data()):
    print(match.group(1))

# Dans une boucle while
# Lire un fichier jusqu'à ligne vide
while (line := input(">>> ")) != "":
    print(f"Vous avez dit: {line}")

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

# Calculer et filtrer en une passe
carres_pairs = [carre for n in nombres if (carre := n**2) % 2 == 0]
print(carres_pairs)  # [4, 16, 36, 64, 100]


[OK] 17. CONDITIONS COMPLEXES - PATTERNS AVANCÉS

# 1. Vérification de plage (range checking)
age = 25

# Chaîne de comparaisons
if 18 <= age <= 65:
    print("Âge adulte actif")

if 0 < note < 100:
    print("Note valide")

# 2. Conditions multiples avec any() et all()
notes = [85, 90, 78, 92]

if all(note >= 60 for note in notes):
    print("Toutes les notes sont passantes")

if any(note >= 90 for note in notes):
    print("Au moins une excellente note")

# 3. Vérification de type
valeur = "123"

if isinstance(valeur, str):
    print("C'est une string")

if isinstance(valeur, (int, float)):
    print("C'est un nombre")

# 4. Conditions avec fonctions
def est_pair(n):
    return n % 2 == 0

def est_positif(n):
    return n > 0

nombre = 4
if est_pair(nombre) and est_positif(nombre):
    print("Nombre pair et positif")

# 5. Dictionnaire de dispatch (alternative au if-elif)
operations = {
    'add': lambda x, y: x + y,
    'sub': lambda x, y: x - y,
    'mul': lambda x, y: x * y,
    'div': lambda x, y: x / y if y != 0 else None
}

operation = 'add'
resultat = operations.get(operation, lambda x, y: None)(10, 5)

# 6. Conditions avec regex
import re

email = "user@example.com"
if re.match(r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$', email):
    print("Email valide")


[OK] 18. EXEMPLES PRATIQUES COMPLETS

# Exemple 1: Validation de formulaire
def valider_formulaire(data):
    """Valide les données d'un formulaire"""
    erreurs = []
    
    # Nom
    if not data.get('nom'):
        erreurs.append("Nom requis")
    elif len(data['nom']) < 2:
        erreurs.append("Nom trop court")
    
    # Email
    if not data.get('email'):
        erreurs.append("Email requis")
    elif '@' not in data['email']:
        erreurs.append("Email invalide")
    
    # Âge
    age = data.get('age', 0)
    if not isinstance(age, int):
        erreurs.append("Âge doit être un nombre")
    elif age < 18:
        erreurs.append("Vous devez être majeur")
    elif age > 120:
        erreurs.append("Âge non valide")
    
    return len(erreurs) == 0, erreurs

# Utilisation
formulaire = {'nom': 'Alice', 'email': 'alice@test.com', 'age': 25}
valide, erreurs = valider_formulaire(formulaire)

if valide:
    print("Formulaire valide!")
else:
    print("Erreurs:")
    for erreur in erreurs:
        print(f"  - {erreur}")


# Exemple 2: Système de permissions
class User:
    def __init__(self, role, verified, banned):
        self.role = role
        self.verified = verified
        self.banned = banned

def peut_publier(user):
    """Vérifie si un utilisateur peut publier"""
    # Guards: vérifier les conditions bloquantes
    if user.banned:
        return False, "Utilisateur banni"
    
    if not user.verified:
        return False, "Email non vérifié"
    
    # Vérifier les permissions selon le rôle
    if user.role in ['admin', 'moderator', 'user']:
        return True, "Autorisation accordée"
    
    return False, "Rôle non autorisé"

# Test
user1 = User(role='user', verified=True, banned=False)
autorise, message = peut_publier(user1)

if autorise:
    print("Publication autorisée")
else:
    print(f"Refusé: {message}")


# Exemple 3: Calculateur de remise
def calculer_prix_final(prix_base, quantite, code_promo=None, est_membre=False):
    """Calcule le prix final avec remises applicables"""
    # Validation
    if prix_base <= 0 or quantite <= 0:
        return None
    
    total = prix_base * quantite
    remise = 0
    
    # Remise sur quantité
    if quantite >= 100:
        remise += total * 0.20  # 20%
    elif quantite >= 50:
        remise += total * 0.15  # 15%
    elif quantite >= 10:
        remise += total * 0.10  # 10%
    
    # Remise membre
    if est_membre:
        remise += total * 0.05  # 5% supplémentaire
    
    # Code promo
    if code_promo:
        code_promo = code_promo.upper()
        if code_promo == "SUMMER20":
            remise += total * 0.20
        elif code_promo == "WELCOME10":
            remise += total * 0.10
    
    # La remise ne peut pas dépasser 50% du total
    remise = min(remise, total * 0.50)
    
    prix_final = total - remise
    return prix_final

# Utilisation
prix = calculer_prix_final(
    prix_base=100,
    quantite=15,
    code_promo="SUMMER20",
    est_membre=True
)
print(f"Prix final: {prix}€")


# Exemple 4: Machine à états simple
class TrafficLight:
    def __init__(self):
        self.state = 'red'
    
    def next_state(self):
        """Change l'état du feu"""
        if self.state == 'red':
            self.state = 'green'
        elif self.state == 'green':
            self.state = 'yellow'
        elif self.state == 'yellow':
            self.state = 'red'
    
    def can_cross(self):
        """Vérifie si on peut traverser"""
        return self.state == 'green'

# Utilisation
light = TrafficLight()

if light.can_cross():
    print("Vous pouvez traverser")
else:
    print(f"Attendez (feu {light.state})")


[OK] 19. BONNES PRATIQUES

# [OK] 1. Conditions positives (plus lisibles)
# Préférer
if user.is_active:
    do_something()

# Au lieu de
if not user.is_inactive:
    do_something()

# [OK] 2. Éviter la négation double
# Préférer
if items:
    process(items)

# Au lieu de
if not not items:  # Confus!
    process(items)

# [OK] 3. Extraire les conditions complexes
# Au lieu de
if (user.age >= 18 and user.verified and not user.banned 
    and user.subscription_active and user.email_confirmed):
    grant_access()

# Préférer
def peut_acceder(user):
    return (user.age >= 18 
            and user.verified 
            and not user.banned
            and user.subscription_active 
            and user.email_confirmed)

if peut_acceder(user):
    grant_access()

# [OK] 4. Utiliser des constantes pour les valeurs magiques
# Au lieu de
if user.status == 1:
    active()

# Préférer
STATUS_ACTIVE = 1
STATUS_INACTIVE = 0
STATUS_BANNED = -1

if user.status == STATUS_ACTIVE:
    active()

# [OK] 5. Éviter les conditions trop imbriquées (max 3 niveaux)
# Utiliser les guard clauses, extraire en fonctions

# [OK] 6. Préférer match-case pour beaucoup de conditions (Python 3.10+)
# Au lieu de long if-elif-elif...

# [OK] 7. Ne pas comparer explicitement à True/False
# Au lieu de
if condition == True:

# Préférer
if condition:

# [OK] 8. Utiliser 'is' pour None, True, False
if value is None:  # Correct
if value == None:  # Éviter


[OK] 20. RÉSUMÉ DES CONCEPTS CLÉS

"""
CONDITIONS BASIQUES:
    if condition:
    if-else:
    if-elif-else:
    
OPÉRATEURS:
    Comparaison: ==, !=, <, >, <=, >=
    Logiques: and, or, not
    Appartenance: in, not in
    Identité: is, is not

PATTERNS AVANCÉS:
    Ternaire: valeur if condition else autre_valeur
    Match-case: pattern matching (Python 3.10+)
    Walrus: := (assignation dans condition)
    Guard clauses: sortir tôt de la fonction

TRUTHINESS:
    Falsy: False, None, 0, "", [], {}, ()
    Truthy: tout le reste

BONNES PRATIQUES:
    - Conditions positives
    - Éviter imbrication excessive (max 3 niveaux)
    - Extraire conditions complexes en fonctions
    - Guard clauses pour éviter imbrication
    - Utiliser constantes pour valeurs magiques
    - is pour None/True/False, == pour valeurs
    - any()/all() pour conditions multiples
"""