Structures de contrôle : conditions et boucles

2.1 Introduction et Motivation

Un programme informatique ne se limite pas à exécuter des instructions séquentiellement de haut en bas. Pour résoudre des problèmes complexes, il doit être capable de prendre des décisions en évaluant des conditions logiques, et de répéter des séquences d'opérations. En Python, la structuration logique du code repose entièrement sur un concept fort : l'indentation. Contrairement à d'autres langages qui utilisent des délimiteurs (accolades \{\} en C/Java, mots-clés begin/end en Pascal), Python utilise l'alignement des lignes pour délimiter les blocs de code. Ce choix de conception impose une lisibilité maximale et une écriture propre.

2.2 Structuration des Blocs et Définition de Fonctions

Le début d'un bloc d'instructions est matérialisé par le caractère deux-points :. Toutes les instructions appartenant à ce même bloc doivent posséder le même niveau d'indentation (généralement 4 espaces). Le retour à l'indentation du niveau parent marque la fin du bloc.

2.2.1 Définition des Fonctions et Routines

On définit une fonction à l'aide du mot-clé def.

def norme_lk(x, y, k):
    return (abs(x)**k + abs(y)**k)**(1/k)

2.2.2 Paramètres Optionnels et Nommés

Il est possible d'attribuer des valeurs par défaut à certains paramètres d'une fonction, les rendant optionnels lors de l'appel.

def norme_lk(x, y, k=2):  # Par défaut, k=2 calcule la norme euclidienne
    return (abs(x)**k + abs(y)**k)**(1/k)

2.2.3 Portée des Variables (Scope)

Chaque fonction possède son propre espace de noms local (sa table de référencement).

• Une variable définie dans une fonction est dite locale : elle est inaccessible de l'extérieur.
• Si une variable du même nom existe globalement, l'affectation à l'intérieur d'une fonction crée par défaut une variable locale, masquant la variable globale sans la modifier.
• Pour modifier une variable globale dans le corps d'une fonction, on doit la déclarer explicitement à l'aide du mot-clé global.

2.3 Instructions Conditionnelles

Les structures conditionnelles permettent d'orienter le flux d'exécution du programme en fonction de la valeur de vérité de prédicats logiques.

if condition_1:
    # bloc exécuté si condition_1 est True
elif condition_2:
    # bloc exécuté si condition_1 est False et condition_2 est True
else:
    # bloc exécuté si toutes les conditions précédentes sont False

Les prédicats comparent des nombres ou des chaînes de caractères (comparaison lexicographique) à l'aide des opérateurs de comparaison (==, !=, <, <=, >, >=).

2.4 Instructions Itératives (Boucles)

Python propose deux types fondamentaux de boucles : la boucle bornée (for) et la boucle conditionnelle (while).

2.4.1 Boucles Énumérées et Indexées (for)

La boucle for permet de parcourir les éléments d'un objet itérable. La fonction range(a, b, c) génère une progression arithmétique d'entiers allant de a (inclus) à b (exclus) avec un pas de c.

for x in range(2, 10, 3):
    print(x, x**2)

2.4.2 Parcours de Séquences, Enumerate et Zip

Python permet de parcourir directement les caractères d'une chaîne ou les éléments d'une liste sans passer par leurs indices. Si l'on a besoin des indices, on utilise enumerate(). Si l'on souhaite parcourir deux séquences en parallèle, on utilise zip().

# Utilisation de enumerate
for idx, char in enumerate("Python"):
    print(f"Index {idx} -> {char}")

# Utilisation de zip
for i, char in zip(range(1, 4), "abcde"):
    print(f"{i} -> {char}")  # S'arrête dès que la plus petite séquence est épuisée

2.4.3 Boucles Conditionnelles (while)

La boucle while répète un bloc d'instructions tant qu'une condition logique est vérifiée.

2.4.4 Contrôle de Sortie : break, continue, return

• break interrompt immédiatement et définitivement la boucle la plus interne.
• continue abandonne l'itération en cours et passe directement à l'évaluation de l'itération suivante.
• return quitte immédiatement la fonction contenant la boucle, renvoyant la valeur spécifiée.

2.5 Théorie des Invariants de Boucle

Un outil fondamental pour prouver la correction logique d'un algorithme itératif est la notion d'invariant.