Conditions
et logique.

• Écrire une condition simple, puis une condition à plusieurs branches.
• Combiner des conditions et prédire leur valeur.
• Comprendre l’indentation, la règle la plus importante de Python.
• Écrire le « cerveau » d’un robot simple qui réagit à des capteurs.

Dans la plupart des langages (C, C++ sur Arduino…), un bloc est délimité par des accolades { }. En Python, c’est le décalage qui délimite le bloc. Quatre espaces, toujours (la touche Tab de l’éditeur intégré les insère). Un mélange d’espaces et de tabulations provoque IndentationError. Quand vous passerez au C sur Arduino, vous garderez l’habitude d’indenter : ce sera « seulement » pour la lisibilité, mais un code non indenté est illisible.

Écrire les conditions dans le désordre. Si l’on met distance < 100 en premier, une distance de 5 déclenche « Avancer prudemment » et jamais le STOP. Règle : du plus précis au plus général, ou bien des bornes croissantes comme ici.

3 < 5 n’est pas une question : c’est une expression qui vaut True. On peut la ranger dans une variable (est_proche = distance < 20), l’afficher, la passer à une fonction. Un if ne fait qu’examiner une valeur booléenne. En Python, True et False prennent une majuscule.

« Fromage ou dessert » au restaurant signifie l’un ou bien l’autre (ou exclusif). Le or de Python est inclusif : vrai aussi quand les deux sont vrais. Le ou exclusif s’écrit A != B pour des booléens, ou A ^ B. Ces trois opérations (ET, OU, NON) suffisent à construire tout circuit numérique, y compris un processeur entier. C’est le théorème fondateur de l’électronique numérique, et les portes logiques d’un CPU ne font rien d’autre.

True, True, True, False, True, False, False. Ordre de priorité : not, puis and, puis or. Comme pour les nombres : au moindre doute, des parenthèses.

Les deux dernières lignes illustrent les lois de De Morgan : not (A and B) équivaut à (not A) or (not B), et not (A or B) équivaut à (not A) and (not B). Vous les retrouverez en maths (ensembles), en logique et en électronique. Vérifiez-les avec une table de vérité : c’est le premier « théorème » que vous pouvez démontrer par calcul exhaustif.

Sont considérés comme faux : 0, 0.0, la chaîne vide "", la liste vide [], None (« rien ») et bien sûr False. Tout le reste est vrai, y compris la chaîne "False" (c’est du texte non vide !). On écrit donc souvent if liste: pour dire « si la liste n’est pas vide ». (Le for est un aperçu de la séance 04.)

couleur = input("Couleur du feu ? ").lower()
if couleur == "vert":
    print("Avancer")
elif couleur == "orange":
    print("Ralentir")
elif couleur == "rouge":
    print("S'arrêter")
else:
    print(f"Couleur inconnue : {couleur}")

.lower() met en minuscules : « ROUGE » et « Rouge » sont alors acceptés. Penser à l’utilisateur qui ne tape pas comme vous l’imaginez est un réflexe d’ingénieur.

annee = int(input("Année ? "))
bissextile = (annee % 4 == 0 and annee % 100 != 0) or annee % 400 == 0
if bissextile:
    print(f"{annee} est bissextile")
else:
    print(f"{annee} n'est pas bissextile")

Remarquez qu’on range la condition dans une variable booléenne avec un nom clair. Le if devient lisible comme une phrase. Autre solution valable : une cascade de if / elif testant d’abord 400, puis 100, puis 4.

a = float(input("a ? "))
b = float(input("b ? "))
c = float(input("c ? "))

if not (a < b + c and b < a + c and c < a + b):
    print("Pas un triangle")
else:
    if a == b == c:
        forme = "équilatéral"
    elif a == b or b == c or a == c:
        forme = "isocèle"
    else:
        forme = "quelconque"

    # Le plus grand côté est l'hypoténuse potentielle
    plus_grand = max(a, b, c)
    somme_carres = a*a + b*b + c*c - plus_grand*plus_grand
    rectangle = abs(somme_carres - plus_grand*plus_grand) < 1e-9

    print(f"Triangle {forme}" + (", rectangle" if rectangle else ""))

Trois idées à retenir : (1) tester d’abord le cas impossible pour se débarrasser des cas dégénérés ; (2) max() évite trois if pour trouver l’hypoténuse ; (3) on ne compare jamais deux flottants avec == après un calcul. Testez 3, 4, 5 puis 0.3, 0.4, 0.5. L’astuce a*a + b*b + c*c - max² donne la somme des carrés des deux petits côtés sans savoir lesquels ils sont : c’est le genre de raccourci qu’on attend en concours.

Exécutez plusieurs fois : les capteurs changent. Ajoutez une règle : si les trois distances sont inférieures à 15, faire « marche arrière ». Où la placer pour qu’elle soit prise en compte ? Cette structure — lire les capteurs, décider, agir — est la boucle de base de tout robot. En séance 28 elle deviendra une machine à états, et sur Arduino vous l’écrirez en C.