La programmation en Python

Python est un langage de programmation de haut niveau, ce qui signifie qu'il est plus proche du langage humain que du langage machine. Il a été créé par Guido van Rossum et publié pour la première fois en 1991.

Pourquoi Python est-il si populaire ?

• Langage interprété : Contrairement aux langages compilés (comme le C++), Python exécute le code ligne par ligne. Cela rend le développement et les tests plus rapides.
• Simplicité et lisibilité : La syntaxe de Python est conçue pour être claire et facile à comprendre, même pour les débutants. C'est comme écrire des phrases en anglais ! L'utilisation de l'indentation pour structurer le code renforce cette lisibilité.
• Applications variées : Python est utilisé dans de nombreux domaines :
  • Développement web (avec des frameworks comme Django ou Flask)
  • Analyse de données et intelligence artificielle (avec des bibliothèques comme NumPy, Pandas, TensorFlow)
  • Automatisation de tâches
  • Création de jeux vidéo
  • Cybersécurité
  • Et bien plus encore !
• Grande communauté : Il existe une immense communauté d'utilisateurs et de développeurs Python, ce qui signifie que vous trouverez facilement de l'aide et des ressources en ligne.
• Multiplateforme : Python fonctionne sur Windows, macOS, Linux, etc.

Pour commencer à programmer en Python, vous devez d'abord l'installer sur votre machine.

1. Installation de Python :

   • Rendez-vous sur le site officiel : python.org
   • Téléchargez la dernière version stable de Python pour votre système d'exploitation.
   • Exécutez l'installateur. N'oubliez pas de cocher la case "Add Python X.X to PATH" pendant l'installation, c'est très important pour pouvoir utiliser Python depuis n'importe quel terminal.

2. Utilisation de l'interpréteur :

   • Une fois installé, ouvrez votre terminal (Invite de commandes sous Windows, Terminal sous macOS/Linux).
   • Tapez python (ou python3 sur certains systèmes) et appuyez sur Entrée.
   • Vous devriez voir apparaître les informations de version de Python et un prompt >>>. C'est l'interpréteur interactif !

3. Exécution de commandes simples :

   • Dans l'interpréteur, vous pouvez taper des commandes Python et voir le résultat immédiatement.
   • Essayez :

     >>> print("Bonjour, le monde !")
     Bonjour, le monde !
     >>> 2 + 3
     5
     >>> 10 / 2
     5.0
     >>> exit() # Pour quitter l'interpréteur
     

   • L'interpréteur est très utile pour tester des petites portions de code ou vérifier la syntaxe.

Bien que l'interpréteur soit pratique pour des tests rapides, pour écrire des programmes plus longs, vous aurez besoin d'un éditeur de code ou d'un IDE (Environnement de Développement Intégré).

Avantages d'un IDE :

• Mise en évidence de la syntaxe : Colore le code pour le rendre plus lisible.
• Autocomplétion : Suggère des noms de fonctions, variables, etc.
• Débogage : Outils pour trouver et corriger les erreurs.
• Gestion de projets : Facilite l'organisation de plusieurs fichiers.
• Exécution directe : Permet d'exécuter votre script directement depuis l'éditeur.

Éditeurs courants :

• IDLE : C'est l'IDE par défaut qui est installé avec Python. Il est simple et suffisant pour débuter.
• Visual Studio Code (VS Code) : Un éditeur de code très populaire, léger, puissant et extensible avec de nombreuses extensions pour Python. C'est un excellent choix pour tous les niveaux.
• PyCharm : Un IDE complet et très puissant, particulièrement apprécié des développeurs professionnels Python. Il est plus lourd mais offre de nombreuses fonctionnalités avancées.

Création et exécution d'un script avec VS Code (exemple) :

1. Ouvrez VS Code.
2. Créez un nouveau fichier (Ctrl+N ou Fichier > Nouveau fichier).
3. Enregistrez-le sous un nom se terminant par .py, par exemple mon_premier_script.py.
4. Écrivez votre code Python dedans :

   # mon_premier_script.py
   nom = "Alice"
   print("Bonjour,", nom)
   age = 16
   print("Tu as", age, "ans.")
   

5. Pour l'exécuter :
   • Ouvrez le terminal intégré de VS Code (Terminal > Nouveau Terminal).
   • Naviguez jusqu'au répertoire où vous avez enregistré votre fichier (utilisez cd pour changer de répertoire).
   • Tapez python mon_premier_script.py et appuyez sur Entrée.
   • Le résultat s'affichera dans le terminal.
   • Alternativement, vous pouvez souvent cliquer sur le bouton "Exécuter" (triangle vert) en haut à droite de l'éditeur ou faire un clic droit sur le fichier et choisir "Exécuter le fichier Python dans le terminal".

Une variable est comme une boîte qui stocke une valeur. En Python, vous n'avez pas besoin de déclarer le type de la variable avant de l'utiliser ; Python le déduit automatiquement. C'est ce qu'on appelle le typage dynamique.

Déclaration de variables :

age = 17            # Une variable nommée 'age' qui contient la valeur 17
nom = "Sophie"      # Une variable 'nom' qui contient la chaîne de caractères "Sophie"
prix_unitaire = 12.50 # Une variable 'prix_unitaire' qui contient la valeur flottante 12.50
est_etudiant = True # Une variable 'est_etudiant' qui contient la valeur booléenne True

Types de données courants :

• Types numériques :
  • int (entiers) : Nombres entiers, positifs ou négatifs, sans partie décimale.

    nombre_eleves = 30
    annee = 2024
    

  • float (flottants) : Nombres à virgule (en Python, on utilise le point pour la décimale).

    taille = 1.75
    temperature = -3.5
    

• Chaînes de caractères (str) : Séquences de caractères (lettres, chiffres, symboles) entourées de guillemets simples ou doubles.

  message = "Bonjour"
  prenom = 'Lucas'
  adresse = "12 rue de la Paix"
  

• Type booléen (bool) : Représente une valeur de vérité, soit True (vrai) soit False (faux). Utilisé principalement dans les conditions.

  est_majeur = True
  a_permis = False
  

Les opérateurs sont des symboles qui effectuent des opérations sur des valeurs et des variables. Une expression est une combinaison de valeurs, variables et opérateurs qui produit une nouvelle valeur.

• Opérateurs arithmétiques : Pour les calculs mathématiques.

  Opérateur	Description	Exemple	Résultat
  +	Addition	5 + 2	7
  -	Soustraction	5 - 2	3
  *	Multiplication	5 * 2	10
  /	Division	5 / 2	2.5
  //	Division entière	5 // 2	2
  %	Modulo (reste)	5 % 2	1
  **	Exposant	5 ** 2	25

• Opérateurs de comparaison : Comparent deux valeurs et renvoient un booléen (True ou False).

  Opérateur	Description	Exemple	Résultat
  <mark>	Égal à	5 </mark> 2	False
  !=	Différent de	5 != 2	True
  <	Inférieur à	5 < 2	False
  >	Supérieur à	5 > 2	True
  <=	Inférieur ou égal à	5 <= 5	True
  >=	Supérieur ou égal à	5 >= 2	True

• Opérateurs logiques : Combinent des expressions booléennes.

  • and : Vrai si les deux expressions sont vraies.

    (5 > 2) and (10 < 20) # True and True -> True
    

  • or : Vrai si au moins une des expressions est vraie.

    (5 < 2) or (10 < 20)  # False or True -> True
    

  • not : Inverse la valeur de vérité d'une expression.

    not (5 == 2)          # not False -> True
    

• Priorité des opérateurs : Comme en mathématiques, certains opérateurs sont évalués avant d'autres.

  1. Parenthèses ()
  2. Exposants **
  3. Multiplication *, Division /, Division entière //, Modulo % (de gauche à droite)
  4. Addition +, Soustraction - (de gauche à droite)
  5. Opérateurs de comparaison <, >, <=, >=, ==, !=
  6. Opérateurs logiques not, and, or (dans cet ordre)

  Exemple : resultat = 2 + 3 * 4 donne 14 (multiplication avant addition). Pour changer l'ordre : resultat = (2 + 3) * 4 donne 20.

Un programme interagit souvent avec l'utilisateur.

• Fonction print() : Pour afficher des informations (sorties) à l'utilisateur.

  print("Ceci est un message.")
  nom = "Julie"
  age = 16
  print("Bonjour", nom, "tu as", age, "ans.") # Affiche "Bonjour Julie tu as 16 ans."
  print(f"Bonjour {nom}, tu as {age} ans.") # Utilisation des f-strings (formatage plus moderne)
  

  print() ajoute automatiquement un espace entre les éléments et passe à la ligne à la fin.

• Fonction input() : Pour demander des informations (entrées) à l'utilisateur. Elle renvoie toujours une chaîne de caractères.

  prenom = input("Quel est ton prénom ? ")
  print("Bonjour,", prenom)
  

• Conversion de types (cast) : Comme input() renvoie toujours une chaîne, vous devez convertir cette chaîne en un autre type si vous voulez l'utiliser pour des calculs.

  • int() : Convertit en entier.
  • float() : Convertit en flottant.
  • str() : Convertit en chaîne de caractères.

  age_str = input("Quel âge as-tu ? ") # L'utilisateur tape "17"
  age_int = int(age_str)               # Convertit "17" en l'entier 17
  annee_naissance = 2024 - age_int
  print("Tu es né(e) en", annee_naissance)
  
  prix_str = input("Entrez un prix : ") # L'utilisateur tape "19.99"
  prix_float = float(prix_str)          # Convertit "19.99" en le flottant 19.99
  print("Le prix est :", prix_float)
  

  Attention : si l'utilisateur entre une valeur non convertible, une erreur se produira.

Les commentaires sont essentiels pour rendre votre code compréhensible, non seulement pour les autres, mais aussi pour vous-même plus tard.

• Rôle des commentaires :

  • Expliquer ce que fait une partie complexe du code.
  • Décrire l'objectif d'une fonction ou d'une variable.
  • Désactiver temporairement une ligne de code pour des tests.
  • Ils sont ignorés par l'interpréteur Python.

• Commentaires monolignes : Commencent par un #.

  # Ceci est un commentaire sur une seule ligne
  x = 10 # C'est la variable x
  

• Commentaires multilignes : En Python, il n'y a pas de syntaxe spécifique pour les commentaires multilignes. On utilise généralement des chaînes de caractères multilignes (entourées de trois guillemets doubles """ ou simples ''') qui ne sont pas assignées à une variable. Elles servent souvent de documentation pour les fonctions ou modules.

  """
  Ceci est un commentaire
  sur plusieurs lignes.
  Il explique le fonctionnement général du script.
  """
  

• Bonnes pratiques de codage :

  • Lisibilité du code : Un code clair est un code facile à maintenir et à déboguer.
  • Indentation : Python utilise l'indentation (généralement 4 espaces) pour définir les blocs de code. C'est crucial ! Une mauvaise indentation provoque des erreurs.

    # Bon
    if True:
        print("Vrai")
    # Mauvais (provoque une erreur IndentationError)
    # if True:
    # print("Vrai")
    

  • Noms de variables significatifs : Choisissez des noms qui décrivent clairement ce que la variable contient.
    • Bon : nombre_etudiants, temperature_actuelle
    • Moins bon : n, temp
  • Respecter les conventions : Python a des conventions de nommage (PEP 8). Par exemple, les noms de variables et de fonctions sont généralement en snake_case (mots en minuscules séparés par des underscores).

Les conditions permettent d'exécuter un bloc de code uniquement si une certaine condition est vraie.

• Structure conditionnelle simple (if) :

  age = 18
  if age >= 18:
      print("Vous êtes majeur.")
  

  Le bloc de code sous if n'est exécuté que si age >= 18 est True.

• Conditions multiples (elif) : Pour tester plusieurs conditions successives.

  note = 14
  if note >= 16:
      print("Très bien")
  elif note >= 12: # Si la première condition est fausse, on teste celle-ci
      print("Bien")
  elif note >= 10:
      print("Assez bien")
  

  Seul le bloc de la première condition vraie sera exécuté.

• Condition par défaut (else) : Exécuté si aucune des conditions if ou elif précédentes n'est vraie.

  heure = 10
  if heure < 12:
      print("Bonjour matin !")
  else: # Si heure n'est pas < 12 (donc >= 12)
      print("Bonjour après-midi !")
  

• Indentation et blocs de code : L'indentation est cruciale en Python pour définir ce qui fait partie de la condition.

  temperature = 25
  if temperature > 20:
      print("Il fait chaud.") # Cette ligne est dans le bloc 'if'
      print("Mettez un t-shirt.") # Cette ligne aussi
  print("Fin du programme.") # Cette ligne n'est pas dans le bloc 'if'
  

Une boucle for est utilisée pour itérer sur une séquence (comme une liste, une chaîne de caractères ou une plage de nombres) un nombre de fois prédéfini.

• Itération sur une séquence :

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

• Fonction range() : Génère une séquence de nombres. Très utile pour répéter une action un nombre fixe de fois.

  • range(n) : Génère des nombres de 0 à n-1.

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

  • range(start, end) : Génère des nombres de start à end-1.

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

  • range(start, end, step) : Génère des nombres de start à end-1 avec un pas de step.

    for i in range(1, 10, 2): # i prendra les valeurs 1, 3, 5, 7, 9
        print(i)
    

• Parcours de chaînes de caractères :

  mot = "Python"
  for lettre in mot:
      print(lettre)
  # Affiche chaque lettre sur une nouvelle ligne
  

Une boucle while répète un bloc de code tant qu'une condition reste vraie. Le nombre d'itérations n'est pas connu à l'avance.

• Répétition tant qu'une condition est vraie :

  compteur = 0
  while compteur < 5:
      print(compteur)
      compteur = compteur + 1 # Incrémente le compteur à chaque tour
  # Affiche : 0, 1, 2, 3, 4
  

• Condition d'arrêt : Il est essentiel que la condition de la boucle while finisse par devenir False pour que la boucle se termine.

  secret = 7
  devinette = 0
  while devinette != secret:
      devinette = int(input("Devinez le nombre secret (entre 1 et 10) : "))
  print("Bravo, vous avez trouvé !")
  

• Boucles infinies et précautions : Si la condition ne devient jamais fausse, la boucle ne s'arrêtera jamais. C'est une boucle infinie, et votre programme se bloquera.

  # ATTENTION : exemple de boucle infinie !
  # x = 10
  # while x > 0:
  #    print("Je tourne en rond !")
  # Pour l'arrêter : Ctrl+C dans le terminal
  

  Assurez-vous toujours qu'une variable impliquée dans la condition de votre boucle while est modifiée à l'intérieur de la boucle, de manière à ce que la condition puisse éventuellement devenir fausse.

Une liste est une collection ordonnée et modifiable d'éléments. Les éléments peuvent être de types différents.

• Définition d'une liste : Entourée de crochets [], les éléments sont séparés par des virgules.

  ma_liste = [1, 2, 3, "quatre", True]
  prenoms = ["Alice", "Bob", "Charlie"]
  

• Accès aux éléments (indexation) : Les éléments sont indexés à partir de 0.

  print(prenoms[0]) # Affiche "Alice"
  print(prenoms[2]) # Affiche "Charlie"
  print(prenoms[-1]) # Accès au dernier élément (Charlie)
  

  Tenter d'accéder à un index inexistant provoquera une erreur IndexError.

• Modification, ajout et suppression d'éléments :

  • Modification :

    prenoms[1] = "Bertrand" # Remplace "Bob" par "Bertrand"
    print(prenoms) # Affiche ['Alice', 'Bertrand', 'Charlie']
    

  • Ajout :
    • append() : Ajoute un élément à la fin de la liste.

      prenoms.append("David")
      print(prenoms) # Affiche ['Alice', 'Bertrand', 'Charlie', 'David']
      

    • insert(index, element) : Insère un élément à un index spécifique.

      prenoms.insert(1, "Clara")
      print(prenoms) # Affiche ['Alice', 'Clara', 'Bertrand', 'Charlie', 'David']
      

  • Suppression :
    • del : Supprime un élément par son index.

      del prenoms[0] # Supprime "Alice"
      print(prenoms) # Affiche ['Clara', 'Bertrand', 'Charlie', 'David']
      

    • remove(valeur) : Supprime la première occurrence d'une valeur.

      prenoms.remove("Bertrand")
      print(prenoms) # Affiche ['Clara', 'Charlie', 'David']
      

    • pop(index) : Supprime et renvoie l'élément à l'index donné (le dernier si aucun index n'est spécifié).

      dernier_ele = prenoms.pop() # Supprime et récupère "David"
      print(prenoms) # Affiche ['Clara', 'Charlie']
      print(dernier_ele) # Affiche "David"
      

• Parcours de listes :

  for prenom in prenoms:
      print(prenom)
  
  # Pour accéder à l'index et à la valeur
  for index, prenom in enumerate(prenoms):
      print(f"À l'index {index} se trouve {prenom}")
  

Un tuple est une collection ordonnée et immuable d'éléments. Une fois créé, un tuple ne peut pas être modifié (ajout, suppression ou modification d'éléments).

• Définition d'un tuple : Entouré de parenthèses ().

  coordonnees = (10, 20)
  jours_semaine = ("Lun", "Mar", "Mer", "Jeu", "Ven", "Sam", "Dim")
  

• Différence avec les listes (immuabilité) :

  # Accès aux éléments : comme les listes
  print(coordonnees[0]) # Affiche 10
  
  # MAIS, ceci provoquerait une erreur TypeError :
  # coordonnees[0] = 15 # Erreur ! Un tuple ne peut pas être modifié.
  

  L'immuabilité est la principale différence.

• Cas d'utilisation des tuples :

  • Lorsque vous avez une collection de données qui ne doit jamais changer (coordonnées GPS, dates de naissance, constantes).
  • Pour retourner plusieurs valeurs à partir d'une fonction.
  • Comme clés dans un dictionnaire (les listes ne peuvent pas être des clés de dictionnaire car elles sont mutables).

Un dictionnaire est une collection non ordonnée de paires clé-valeur. Chaque clé doit être unique et immuable (comme une chaîne de caractères, un nombre ou un tuple). Les valeurs peuvent être de n'importe quel type.

• Définition d'un dictionnaire : Entouré d'accolades {}, chaque paire clé-valeur est séparée par des deux-points :, et les paires sont séparées par des virgules.

  eleve = {
      "nom": "Dupont",
      "prenom": "Léa",
      "age": 16,
      "notes": [15, 12, 18]
  }
  

• Accès et modification par clé :

  • Accès :

    print(eleve["nom"]) # Affiche "Dupont"
    print(eleve["age"]) # Affiche 16
    # Si la clé n'existe pas, cela provoque une erreur KeyError.
    # Utilisez dict.get(cle, valeur_par_defaut) pour éviter l'erreur :
    print(eleve.get("ville", "Non spécifiée")) # Affiche "Non spécifiée"
    

  • Modification :

    eleve["age"] = 17 # Modifie la valeur associée à la clé "age"
    print(eleve)
    

• Ajout et suppression d'éléments :

  • Ajout : Si la clé n'existe pas, une nouvelle paire clé-valeur est ajoutée.

    eleve["ville"] = "Paris"
    print(eleve)
    

  • Suppression :
    • del : Supprime une paire clé-valeur par sa clé.

      del eleve["notes"]
      print(eleve)
      

    • pop(clé) : Supprime et renvoie la valeur associée à la clé.

      nom_supprime = eleve.pop("prenom")
      print(eleve)
      print(nom_supprime) # Affiche "Léa"
      

• Parcours de dictionnaires :

  # Parcourt les clés par défaut
  for cle in eleve:
      print(cle)
  
  # Parcourt les valeurs
  for valeur in eleve.values():
      print(valeur)
  
  # Parcourt les paires clé-valeur
  for cle, valeur in eleve.items():
      print(f"{cle}: {valeur}")
  

• Mot-clé def : Pour définir une fonction.

  def saluer(): # Définition d'une fonction sans paramètres
      print("Bonjour !")
  
  saluer() # Appel de la fonction
  saluer() # On peut l'appeler plusieurs fois
  

• Paramètres et arguments : Les paramètres sont les variables définies dans la déclaration de la fonction. Les arguments sont les valeurs passées à la fonction lors de son appel.

  def saluer_personne(nom): # 'nom' est un paramètre
      print(f"Bonjour, {nom} !")
  
  saluer_personne("Alice") # "Alice" est un argument
  saluer_personne("Bob")
  

  Une fonction peut avoir plusieurs paramètres.

• Valeur de retour (return) : Une fonction peut renvoyer une valeur en utilisant le mot-clé return.

  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
  
  def est_pair(nombre):
      if nombre % 2 <mark> 0:
          return True
      else:
          return False
  
  print(est_pair(4)) # Affiche True
  print(est_pair(7)) # Affiche False
  

  Si une fonction ne contient pas de return explicite, elle renvoie implicitement None==.

• Réutilisation du code : C'est le principal avantage des fonctions. Au lieu de copier-coller le même code, on l'encapsule dans une fonction et on l'appelle quand on en a besoin.

La portée d'une variable détermine où elle peut être accédée et utilisée dans votre programme.

• Variables locales :

  • Définies à l'intérieur d'une fonction.
  • Elles ne sont accessibles qu'à l'intérieur de cette fonction.
  • Elles sont créées lorsque la fonction est appelée et détruites lorsque la fonction se termine.

  def ma_fonction():
      x = 10 # x est une variable locale
      print(x)
  
  ma_fonction() # Affiche 10
  # print(x) # Ceci provoquerait une erreur NameError, car x n'est pas accessible ici
  

• Variables globales :

  • Définies en dehors de toute fonction (au niveau principal du script).
  • Elles sont accessibles partout dans le programme, y compris à l'intérieur des fonctions.

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

  Il est généralement déconseillé de modifier une variable globale à l'intérieur d'une fonction sans utiliser le mot-clé global, car cela peut rendre le code difficile à suivre. Si vous devez modifier une variable globale, il est souvent préférable de la passer en argument et de renvoyer la nouvelle valeur.

• Impact sur le comportement du programme : Comprendre la portée est crucial pour éviter les erreurs et écrire un code prévisible. Une variable locale peut avoir le même nom qu'une variable globale sans conflit, car elles vivent dans des espaces de noms différents.

Un module est un fichier Python (.py) contenant du code (fonctions, classes, variables) que vous pouvez inclure dans d'autres programmes. Ils permettent d'organiser le code et de le rendre réutilisable.

• Importation de modules (import) :

  • Pour utiliser le code d'un module, vous devez l'importer.

  import math # Importe tout le module 'math'
  
  print(math.pi) # Accède à la constante pi du module math
  print(math.sqrt(25)) # Appelle la fonction sqrt (racine carrée) du module math
  

  • Vous pouvez importer des éléments spécifiques pour ne pas avoir à écrire le nom du module à chaque fois :

  from math import pi, sqrt # Importe seulement pi et sqrt du module math
  
  print(pi)
  print(sqrt(36))
  

  • Ou importer tout, mais c'est moins recommandé car cela peut créer des conflits de noms :

  from math import * # Importe tout du module math (à éviter généralement)
  

• Modules courants :

  • math : Fonctions et constantes mathématiques (racine carrée, trigonométrie, pi, etc.).
  • random : Génération de nombres aléatoires.

    import random
    nombre_aleatoire = random.randint(1, 10) # Génère un entier aléatoire entre 1 et 10 inclus
    print(nombre_aleatoire)
    
    choix = random.choice(["pierre", "feuille", "ciseaux"]) # Choisit un élément aléatoire d'une liste
    print(choix)
    

  • datetime : Manipulation de dates et heures.
  • os : Interaction avec le système d'exploitation.

• Fonctions et constantes des modules : Une fois importé, vous pouvez utiliser les fonctions, variables et autres éléments définis dans le module en utilisant la syntaxe nom_du_module.nom_de_l_element.

• Erreurs de syntaxe (SyntaxError) :

  • Ce sont les erreurs les plus faciles à repérer car Python les détecte avant même d'exécuter le code.
  • Elles surviennent lorsque vous ne respectez pas les règles de grammaire du langage Python.
  • Exemples : parenthèses manquantes, deux-points oubliés, mauvaise indentation.

  # print("Bonjour" # Manque une parenthèse fermante
  # if x > 5     # Manque les deux-points
  

  L'interpréteur vous indiquera la ligne où l'erreur a été détectée.

• Erreurs d'exécution (exceptions) :

  • Ces erreurs surviennent pendant que le programme est en cours d'exécution.
  • Le programme s'arrête brusquement et affiche un message d'erreur (une "traceback").
  • Exemples :
    • NameError : Utilisation d'une variable non définie.

      # print(variable_inconnue)
      

    • TypeError : Opération effectuée sur un type de données inapproprié (ex: additionner un nombre et une chaîne).

      # "Bonjour" + 5
      

    • ValueError : Une fonction reçoit un argument du bon type, mais avec une valeur inappropriée (ex: int("abc")).

      # int(input("Entrez un nombre : ")) # Si l'utilisateur tape "texte"
      

    • IndexError : Accès à un index qui n'existe pas dans une liste ou une chaîne.

      # ma_liste = [1, 2]
      # print(ma_liste[2])
      

    • ZeroDivisionError : Tentative de division par zéro.

      # 10 / 0
      

• Erreurs logiques :

  • Le programme s'exécute sans erreur, mais le résultat n'est pas celui attendu.
  • Ce sont les erreurs les plus difficiles à trouver car Python ne vous dit pas qu'il y a un problème.
  • Exemple : Un calcul est faux, une condition if n'est pas correcte, une boucle ne se termine pas au bon moment.

  # Calcul de la moyenne sans prendre en compte le bon nombre d'éléments
  notes = [10, 15, 20]
  moyenne = (notes[0] + notes[1]) / 2 # Erreur logique, devrait diviser par 3
  print(moyenne) # Affiche 12.5 au lieu de 15
  

Le débogage est le processus de recherche et de correction des erreurs.

• Utilisation de print() pour le suivi :

  • C'est la technique la plus simple et la plus courante.
  • Insérez des instructions print() à des endroits clés de votre code pour afficher la valeur des variables, vérifier si un bloc de code est exécuté, etc.

  def calculer_surface_rectangle(longueur, largeur):
      print(f"DEBUG: Longueur = {longueur}, Largeur = {largeur}") # Ajout d'un print de débogage
      surface = longueur * largeur
      return surface
  
  s = calculer_surface_rectangle(5, 0)
  print(f"La surface est : {s}")
  

  Cela vous aidera à suivre le flux d'exécution et les valeurs des variables.

• Lecture des messages d'erreur (traceback) :

  • Quand une exception se produit, Python affiche une "traceback". Lisez-la attentivement !
  • Elle vous indique :
    1. Le type d'erreur (NameError, TypeError, etc.).
    2. La ligne exacte du fichier où l'erreur s'est produite.
    3. La séquence d'appels de fonctions qui a mené à l'erreur.
  • Concentrez-vous sur la dernière ligne du message (le type d'erreur) et la ligne de code indiquée.

• Débogueur intégré (si disponible) :

  • Les IDE comme VS Code ou PyCharm ont des débogueurs intégrés.
  • Ils vous permettent de :
    • Définir des points d'arrêt (breakpoints) : Le programme s'arrête à ces points.
    • Exécuter le code pas à pas : Une instruction à la fois.
    • Inspecter les variables : Voir les valeurs de toutes les variables à chaque étape.
    • Avancer (step over), entrer dans une fonction (step into), sortir d'une fonction (step out).
  • L'utilisation d'un débogueur est une compétence avancée mais très puissante pour trouver des erreurs logiques complexes. Apprenez à l'utiliser dès que vous vous sentez à l'aise avec les bases du codage.