Algorithmique et programmation : fonctions et boucles

Un algorithme est une suite finie et non ambiguë d'instructions ou d'opérations permettant de résoudre un problème donné ou d'obtenir un résultat spécifique. Imaginez une recette de cuisine : elle vous donne des étapes précises à suivre pour préparer un plat. Un algorithme, c'est exactement cela, mais pour un ordinateur !

Key Concepts:

• Définition d'un algorithme : C'est une séquence d'instructions claires et ordonnées pour accomplir une tâche. Il doit toujours se terminer et produire un résultat.
• Étapes de résolution d'un problème :
  1. Comprendre le problème : Qu'est-ce que l'on doit faire ? Quels sont les inputs (entrées) et les outputs (sorties) attendus ?
  2. Concevoir l'algorithme : Écrire les étapes logiques pour résoudre le problème, souvent en pseudo-code ou avec des organigrammes.
  3. Coder l'algorithme : Traduire les étapes de l'algorithme dans un langage de programmation (ici, Python).
  4. Tester et déboguer : Vérifier que le programme fonctionne correctement et corriger les erreurs.
• Exemples d'algorithmes simples :
  • Calculer la somme de deux nombres.
  • Trouver le plus grand de trois nombres.
  • Trier une liste de noms par ordre alphabétique.

En programmation, une variable est comme une boîte nommée dans laquelle on peut stocker des informations. Ces informations peuvent être de différents types.

Key Concepts:

• Déclaration et affectation de variables : En Python, on n'a pas besoin de "déclarer" explicitement le type d'une variable avant de l'utiliser. On l'affecte directement.
  • nom = "Alice" (affecte la chaîne de caractères "Alice" à la variable nom)
  • age = 17 (affecte l'entier 17 à la variable age)
  • prix = 19.99 (affecte le nombre décimal 19.99 à la variable prix)
• Types numériques :
  • Entiers (int) : Nombres sans partie décimale (ex: 5, -10, 0).
  • Flottants (float) : Nombres avec une partie décimale (ex: 3.14, -0.5, 100.0).
• Types de chaînes de caractères (str) et booléens (bool) :
  • Chaînes de caractères : Séquences de caractères (lettres, chiffres, symboles) entourées de guillemets simples ou doubles (ex: "Bonjour", 'Python').
  • Booléens : Représentent une valeur de vérité. Ils ne peuvent prendre que deux valeurs : True (vrai) ou False (faux). Ils sont très utiles pour les conditions.

Les opérateurs sont des symboles qui réalisent des opérations sur des valeurs ou des variables, appelées opérandes. Une expression est une combinaison d'opérandes et d'opérateurs qui produit une valeur.

Key Concepts:

• Opérateurs arithmétiques : Pour les calculs mathématiques.
  • + (addition) : 5 + 3 donne 8
  • - (soustraction) : 10 - 2 donne 8
  • * (multiplication) : 4 * 6 donne 24
  • / (division flottante) : 7 / 2 donne 3.5
  • // (division entière) : 7 // 2 donne 3 (le quotient)
  • % (modulo) : 7 % 2 donne 1 (le reste de la division)
  • ** (exponentiation) : 2 ** 3 donne 8 ($2^3$)
• Opérateurs de comparaison : Pour comparer des valeurs, ils renvoient un booléen (True ou False).
  • <mark> (égal à) : 5 </mark> 5 est True, 5 == 6 est False
  • != (différent de) : 5 != 6 est True
  • < (strictement inférieur à) : 3 < 5 est True
  • > (strictement supérieur à) : 5 > 3 est True
  • <= (inférieur ou égal à) : 5 <= 5 est True
  • >= (supérieur ou égal à) : 5 >= 3 est True
• Opérateurs logiques (ET, OU, NON) : Pour combiner des expressions booléennes.
  • and (ET logique) : (True and False) est False. Vrai si les deux sont Vrai.
  • or (OU logique) : (True or False) est True. Vrai si au moins un est Vrai.
  • not (NON logique) : not True est False. Inverse la valeur de vérité.

Un programme interagit souvent avec l'utilisateur ou affiche des informations.

Key Concepts:

• Fonction input() pour la saisie utilisateur : Permet au programme de demander une information à l'utilisateur via le clavier. La valeur saisie est toujours une chaîne de caractères.

  nom = input("Quel est votre nom ? ")
  print("Bonjour, " + nom + "!")
  

• Fonction print() pour l'affichage : Permet d'afficher des informations (texte, valeurs de variables) à l'écran.
  • print("Ceci est un message.")
  • age = 20
  • print("Votre âge est :", age, "ans.")
  • On peut séparer les éléments par des virgules (ils seront espacés) ou les concaténer avec + (pour les chaînes uniquement).
• Conversion de types (cast) : Puisque input() renvoie toujours une chaîne, il faut souvent la convertir si on veut faire des calculs.
  • age_str = input("Entrez votre âge : ")
  • age_int = int(age_str) # Convertit la chaîne en entier
  • taille_str = input("Entrez votre taille (en mètres) : ")
  • taille_float = float(taille_str) # Convertit la chaîne en flottant
  • On peut aussi convertir des nombres en chaînes avec str().

Key Concepts:

• Syntaxe def : On définit une fonction en utilisant le mot-clé def, suivi du nom de la fonction, de parenthèses () qui peuvent contenir des paramètres, et d'un double-point :. Le corps de la fonction est indenté.

  def saluer(): # Définition de la fonction
      print("Bonjour tout le monde !")
  

• Corps de la fonction : C'est l'ensemble des instructions qui seront exécutées lorsque la fonction est appelée. Elles doivent être indentées (généralement 4 espaces).
• Appel de fonction : Pour exécuter le code d'une fonction, il faut l'appeler par son nom, suivi de parenthèses.

  saluer() # Appel de la fonction
  # Affiche : Bonjour tout le monde !
  

  Une fonction n'est exécutée que lorsqu'elle est appelée.

Pour rendre les fonctions plus flexibles, on peut leur passer des informations.

Key Concepts:

• Passage de paramètres : Les paramètres sont des variables définies dans les parenthèses de la définition de la fonction. Elles agissent comme des placeholders pour les valeurs que la fonction recevra.

  def saluer_personne(nom): # 'nom' est un paramètre
      print("Bonjour, " + nom + " !")
  

• Arguments positionnels : Lors de l'appel de la fonction, les valeurs que l'on passe sont appelées arguments. Si on les passe dans l'ordre des paramètres, ce sont des arguments positionnels.

  saluer_personne("Alice") # "Alice" est un argument
  saluer_personne("Bob")
  # Affiche : Bonjour, Alice !
  # Affiche : Bonjour, Bob !
  

• Arguments nommés : On peut spécifier le nom du paramètre lors de l'appel, ce qui rend l'ordre moins important et le code plus lisible pour des fonctions avec de nombreux paramètres.

  def afficher_info(nom, age):
      print(f"Nom: {nom}, Âge: {age}")
  
  afficher_info(age=30, nom="Carole") # Arguments nommés
  # Affiche : Nom: Carole, Âge: 30
  

Les fonctions peuvent non seulement effectuer des actions (comme print), mais aussi calculer une valeur et la renvoyer.

Key Concepts:

• Instruction return : Le mot-clé return est utilisé pour renvoyer une valeur de la fonction à l'endroit où elle a été appelée. Dès que return est exécuté, la fonction se termine.

  def additionner(a, b):
      resultat = a + b
      return resultat # La fonction renvoie la valeur de 'resultat'
  
  somme = additionner(5, 3) # La valeur 8 est renvoyée et stockée dans 'somme'
  print(somme) # Affiche : 8
  

• Fonctions sans retour explicite : Si une fonction ne contient pas d'instruction return, elle renvoie implicitement la valeur spéciale None (qui représente l'absence de valeur).
• Retour de multiples valeurs : Une fonction peut renvoyer plusieurs valeurs en les séparant par des virgules. Python les regroupera automatiquement dans un tuple.

  def operations(x, y):
      somme = x + y
      produit = x * y
      return somme, produit # Renvoie un tuple (somme, produit)
  
  s, p = operations(10, 2) # On peut déballer le tuple directement dans des variables
  print(f"Somme: {s}, Produit: {p}") # Affiche : Somme: 12, Produit: 20
  

  L'instruction return est cruciale pour qu'une fonction puisse communiquer un résultat utilisable à la partie du programme qui l'a appelée.

La portée d'une variable détermine où dans le code cette variable est accessible.

Key Concepts:

• Variables locales : Une variable définie à l'intérieur d'une fonction n'est accessible qu'à l'intérieur de cette fonction. Elle est créée lorsque la fonction est appelée et détruite lorsqu'elle se termine.

  def ma_fonction():
      x = 10 # x est une variable locale
      print(x)
  
  ma_fonction() # Affiche : 10
  # print(x) # Ceci provoquerait une erreur car x n'existe pas en dehors de la fonction
  

• Variables globales : Une variable définie en dehors de toute fonction (au niveau principal du script) est une variable globale. Elle est accessible de partout dans le script, y compris à l'intérieur des fonctions.

  y = 20 # y est une variable globale
  
  def autre_fonction():
      print(y) # La fonction peut accéder à y
  
  autre_fonction() # Affiche : 20
  print(y) # Affiche : 20
  

• Mot-clé global (usage déconseillé) : Si vous voulez modifier une variable globale depuis l'intérieur d'une fonction, vous devez utiliser le mot-clé global. Cependant, modifier des variables globales depuis des fonctions est souvent considéré comme une mauvaise pratique car cela rend le code plus difficile à comprendre et à maintenir. Il est préférable de passer les valeurs en paramètres et de les renvoyer avec return.

  compteur = 0 # Variable globale
  
  def incrementer():
      global compteur # Déclare que nous voulons modifier la variable globale 'compteur'
      compteur += 1
  
  incrementer()
  print(compteur) # Affiche : 1
  

Key Concepts:

• Condition d'arrêt : La boucle continue de s'exécuter tant que la condition spécifiée est True. Dès que la condition devient False, la boucle s'arrête et le programme continue après la boucle.
• Itération : Chaque passage dans la boucle est appelé une itération.
• Risque de boucle infinie : Si la condition ne devient jamais False, la boucle ne s'arrêtera jamais. Le programme restera bloqué. Il faut toujours s'assurer que quelque chose à l'intérieur de la boucle finira par modifier une variable impliquée dans la condition pour la rendre fausse.

Key Concepts:

• Structure while condition: : Le mot-clé while est suivi de la condition à tester, puis d'un double-point :. Le bloc d'instructions à répéter est indenté.

  compteur = 0
  while compteur < 5: # Tant que compteur est inférieur à 5
      print(compteur)
      compteur += 1 # Incrémente le compteur pour éviter une boucle infinie
  print("Boucle terminée.")
  # Affiche : 0, 1, 2, 3, 4, puis "Boucle terminée."
  

• Incrémentation/Décrémentation : Très souvent, une variable est utilisée comme compteur et est incrémentée (+= 1) ou décrémentée (-= 1) à chaque itération pour contrôler la fin de la boucle.
• Utilisation avec des compteurs : Comme dans l'exemple ci-dessus, un compteur est une variable qui suit le nombre d'itérations.

Key Concepts:

• Saisie sécurisée d'informations : Demander à l'utilisateur de saisir une information jusqu'à ce qu'elle soit valide.

  mot_de_passe = ""
  while mot_de_passe != "secret":
      mot_de_passe = input("Entrez le mot de passe : ")
      if mot_de_passe != "secret":
          print("Mot de passe incorrect. Réessayez.")
  print("Accès autorisé.")
  

• Calculs itératifs (ex: suite de Syracuse) : Des algorithmes où le calcul dépend du résultat de l'itération précédente.

  n = int(input("Entrez un nombre entier positif : "))
  print(f"Suite de Syracuse pour {n}:")
  while n != 1:
      print(n)
      if n % 2 == 0: # Si n est pair
          n = n // 2
      else: # Si n est impair
          n = 3 * n + 1
  print(n) # Affiche le dernier 1
  

• Recherche d'un élément : Parcourir une structure de données jusqu'à trouver un élément spécifique ou atteindre la fin.

Key Concepts:

• Itération sur une séquence : La boucle for est conçue pour parcourir chaque élément d'une collection.
• Élément courant : À chaque passage de la boucle, une variable prend la valeur de l'élément suivant dans la séquence.
• Fin de séquence : La boucle s'arrête automatiquement une fois que tous les éléments de la séquence ont été parcourus.

La fonction range() génère une séquence de nombres. Elle est très souvent utilisée avec la boucle for pour répéter un certain nombre de fois.

Key Concepts:

• Fonction range(stop) : Génère des nombres de 0 (inclus) jusqu'à stop (exclu).

  for i in range(5): # i prendra les valeurs 0, 1, 2, 3, 4
      print(i)
  # Affiche : 0, 1, 2, 3, 4
  

• Fonction range(start, stop) : Génère des nombres de start (inclus) jusqu'à stop (exclu).

  for i in range(2, 7): # i prendra les valeurs 2, 3, 4, 5, 6
      print(i)
  # Affiche : 2, 3, 4, 5, 6
  

• Fonction range(start, stop, step) : Génère des nombres de start (inclus) jusqu'à stop (exclu), en progressant par pas de step.

  for i in range(0, 10, 2): # i prendra les valeurs 0, 2, 4, 6, 8
      print(i)
  # Affiche : 0, 2, 4, 6, 8
  

Key Concepts:

• Parcourir une liste :

  fruits = ["pomme", "banane", "cerise"]
  for fruit in fruits:
      print(fruit)
  # Affiche : pomme, banane, cerise (chacun sur une ligne)
  

• Parcourir une chaîne de caractères : Une chaîne est une séquence de caractères.

  mot = "Python"
  for lettre in mot:
      print(lettre)
  # Affiche : P, y, t, h, o, n (chacun sur une ligne)
  

• Accès aux indices avec enumerate() : Si vous avez besoin à la fois de l'élément et de son indice dans la séquence, utilisez enumerate().

  noms = ["Alice", "Bob", "Charlie"]
  for index, nom in enumerate(noms):
      print(f"L'élément à l'indice {index} est {nom}")
  # Affiche :
  # L'élément à l'indice 0 est Alice
  # L'élément à l'indice 1 est Bob
  # L'élément à l'indice 2 est Charlie
  

Key Concepts:

• Calcul de sommes ou produits :

  somme = 0
  for i in range(1, 6): # Pour les nombres de 1 à 5
      somme += i # équivalent à somme = somme + i
  print(f"La somme des nombres de 1 à 5 est : {somme}") # Affiche : 15
  

• Traitement d'éléments d'une collection : Appliquer une opération à chaque élément d'une liste.

  notes = [12, 15, 9, 18, 10]
  for i in range(len(notes)): # len(notes) donne la taille de la liste
      notes[i] += 1 # Augmente chaque note de 1 point
  print(notes) # Affiche : [13, 16, 10, 19, 11]
  

• Génération de motifs : Afficher des formes textuelles, par exemple des triangles d'étoiles.

  for i in range(1, 6): # Pour i de 1 à 5
      print("*" * i) # Affiche i étoiles
  # Affiche :
  # *
  # **
  # ***
  # ****
  # *****
  

Key Concepts:

• Sortie anticipée de boucle : L'instruction break permet de sortir immédiatement de la boucle la plus proche qui l'encapsule. Le code après la boucle s'exécute.
• Utilisation dans 'while' :

  compteur = 0
  while True: # Boucle infinie par design, on compte sur 'break'
      print(compteur)
      compteur += 1
      if compteur == 3:
          break # Sort de la boucle quand compteur atteint 3
  print("Fin de la boucle while.")
  # Affiche : 0, 1, 2, puis "Fin de la boucle while."
  

• Utilisation dans 'for' :

  nombres = [1, 5, 8, 12, 3, 7]
  for n in nombres:
      if n > 10:
          print(f"Premier nombre supérieur à 10 trouvé : {n}")
          break # Sort de la boucle
      print(f"Traitement de {n}")
  print("Boucle for terminée.")
  # Affiche :
  # Traitement de 1
  # Traitement de 5
  # Traitement de 8
  # Premier nombre supérieur à 10 trouvé : 12
  # Boucle for terminée.
  

  break est utile pour optimiser les recherches ou gérer des conditions d'erreur.

Key Concepts:

• Passer à l'itération suivante : L'instruction continue permet de sauter le reste du code de l'itération actuelle et de passer directement à l'itération suivante de la boucle.
• Ignorer le reste du bloc : Tout ce qui se trouve après continue dans le bloc de la boucle pour l'itération en cours est ignoré.

  for i in range(5):
      if i == 2:
          continue # Saute l'itération quand i est 2
      print(i)
  # Affiche : 0, 1, 3, 4 (le 2 est ignoré)
  

• Différence avec 'break' : break arrête complètement la boucle, tandis que continue arrête seulement l'itération actuelle et passe à la suivante.

Key Concepts:

• Boucles à l'intérieur de boucles : On peut placer une boucle à l'intérieur d'une autre boucle. L'intérieur de la boucle interne est exécuté complètement pour chaque itération de la boucle externe.
• Ordre d'exécution : La boucle externe fait une itération, puis la boucle interne fait toutes ses itérations, puis la boucle externe fait sa deuxième itération, et ainsi de suite.
• Exemples (matrices, tables de multiplication) :
  • Tables de multiplication :

    for i in range(1, 4): # Boucle externe pour les multiplicateurs
        for j in range(1, 11): # Boucle interne pour les multiplicandes
            print(f"{i} x {j} = {i * j}")
        print("-" * 10) # Séparateur entre les tables
    

  • Matrices ou grilles :

    for ligne in range(3):
        for colonne in range(3):
            print(f"({ligne},{colonne})", end=" ") # end=" " évite le saut de ligne
        print() # Passe à la ligne suivante après chaque ligne de colonnes
    # Affiche :
    # (0,0) (0,1) (0,2)
    # (1,0) (1,1) (1,2)
    # (2,0) (2,1) (2,2)
    

  Les boucles imbriquées peuvent rapidement augmenter la complexité du programme, soyez attentifs à leur performance si vous travaillez avec de grandes quantités de données.

Key Concepts:

• Analyse du problème : Comprendre précisément ce que le programme doit faire.
  • Quelles sont les entrées (inputs) ?
  • Quelles sont les sorties (outputs) attendues ?
  • Quelles sont les contraintes (par exemple, les nombres doivent être positifs, la liste ne peut pas être vide) ?
• Décomposition en sous-problèmes : Les gros problèmes sont plus faciles à résoudre s'ils sont divisés en plus petits problèmes gérables. C'est là que les fonctions deviennent très utiles !
  • Exemple : "Créer un jeu" peut être décomposé en "afficher le plateau", "gérer les mouvements du joueur", "vérifier la fin du jeu", etc.
• Écriture de pseudo-code : Avant d'écrire le code réel, il est souvent utile d'écrire l'algorithme en langage naturel, avec une structure proche de la programmation, mais sans se soucier de la syntaxe exacte. Cela permet de se concentrer sur la logique.
  • Exemple de pseudo-code pour calculer la moyenne :

    FONCTION calculer_moyenne(liste_nombres):
        SI liste_nombres EST VIDE ALORS
            RETOURNER 0
        FIN SI
        somme = 0
        POUR CHAQUE nombre DANS liste_nombres:
            somme = somme + nombre
        FIN POUR
        moyenne = somme / NOMBRE_ELEMENTS(liste_nombres)
        RETOURNER moyenne
    FIN FONCTION
    

Une fois le code écrit, il est crucial de le tester pour s'assurer qu'il fait ce qu'on attend.

Key Concepts:

• Jeux de tests : Préparer un ensemble de données d'entrée avec les résultats attendus.
  • Exemple : Pour une fonction qui additionne deux nombres, les tests pourraient être (2, 3) <span class="hk-arr">→</span> 5, (-1, 1) <span class="hk-arr">→</span> 0, (0, 0) <span class="hk-arr">→</span> 0.
• Cas limites : Tester les situations extrêmes ou inhabituelles qui pourraient casser le programme.
  • Pour une fonction de division : diviser par zéro (devrait provoquer une erreur ou être géré).
  • Pour une fonction qui prend une liste : une liste vide, une liste avec un seul élément, une liste très longue.
  • Pour des entrées utilisateur : des chaînes vides, des nombres négatifs si seuls les positifs sont attendus.
• Vérification manuelle : Parfois, exécuter le code pas à pas (mentalement ou avec un débogueur) avec des valeurs simples pour comprendre son comportement.

Les bugs (erreurs) font partie intégrante de la programmation. Le débogage est le processus de trouver et de corriger ces erreurs.

Key Concepts:

• Affichages intermédiaires (print) : La méthode la plus simple. Ajouter des instructions print() à des endroits clés du code pour afficher la valeur des variables à différents moments. Cela aide à suivre le déroulement du programme et à identifier où les choses tournent mal.

  def calculer_produit(a, b):
      print(f"Début de calculer_produit avec a={a}, b={b}")
      resultat = a * b
      print(f"Résultat intermédiaire : {resultat}")
      return resultat
  

• Utilisation d'un débogueur simple : Des outils de débogage (souvent intégrés aux IDE comme VS Code ou PyCharm) permettent d'exécuter le code pas à pas, de mettre des points d'arrêt (breakpoints) et d'inspecter les valeurs des variables à n'importe quel moment. C'est beaucoup plus puissant que des print.
• Lecture des messages d'erreur : Quand un programme plante, Python affiche un message d'erreur (un traceback). Lisez-le attentivement ! Il indique :
  • Le type d'erreur (ex: NameError, TypeError, IndexError).
  • Le fichier et la ligne où l'erreur s'est produite.
  • La pile d'appels qui a mené à l'erreur. Ces informations sont cruciales pour localiser la source du problème.