2.5.1. Tutoriel 5: Bonnes pratiques de programmation#
Dans cette section, nous aborderons les points suivants:
🧑🏫 Classe : Apprenez à structurer votre code avec des classes et à encapsuler des comportements dans des objets.
📜 Contrôle des versions : Découvrez comment suivre et gérer les modifications de votre code avec des outils de gestion de versions comme Git.
✅ Assertion : Maîtrisez l’utilisation des assertions pour vérifier que vos hypothèses de code sont correctes pendant l’exécution.
🧪 Unit testing : Initiez-vous aux tests unitaires pour garantir que chaque partie de votre code fonctionne comme prévu de manière isolée.
🚨 Exception : Comprenez comment gérer les erreurs et exceptions pour rendre votre code plus robuste et fiable.
🐞 Débogage : Explorez les outils et techniques pour identifier et corriger les bugs dans votre programme de manière efficace.
2.5.1.1. Classes#
Jusqu’à présent, nous avons manipulé plusieurs types d’objets en Python : des chaînes de caractères, des listes, des dictionnaires, et bien plus encore. Chacun de ces objets possède ses propres attributs et se comporte différemment lorsqu’on utilise des fonctions intégrées comme len, par exemple.
Mais comment créer nos propres objets avec des comportements sur mesure ? 🤔 Réponse : en définissant des classes ! 🎉
2.5.1.1.1. Une classe pour représenter un ouragan#
Créons ensemble notre première classe pour représenter un ouragan. Mais attention… saurez-vous définir un ouragan à temps ? ⏱️🌪️
class Hurricane:
def __init__(self, name):
self.name = name
Et maintenant, créons une instance de cette classe, h :
h = Hurricane('Milton')
print(h,h.name)
<__main__.Hurricane object at 0x7fa0589dcfd0> Milton
Ajoutons-en d’autres, ainsi qu’une validation des entrées :
class Hurricane:
def __init__(self, name, category, lon):
self.name = name.upper()
self.category = int(category)
if lon > 180 or lon < -180:
raise ValueError(f'Invalid lon {lon}')
self.lon = lon
h = Hurricane('florence', 4, -46)
print(h,h.name)
h = Hurricane('Milton', 5, -86.9)
<__main__.Hurricane object at 0x7fa0589f4f10> FLORENCE
# Ajoutons maintenant une méthode personnalisée :class Hurricane:
class Hurricane:
def __init__(self, name, category, lon):
self.name = name.upper()
self.category = int(category)
if lon > 180 or lon < -180:
raise ValueError(f'Invalid lon {lon}')
self.lon = lon
def is_dangerous(self):
return self.category > 1
f = Hurricane('florence', 4, -46)
f.is_dangerous()
True
2.5.1.1.2. Méthodes magiques / Dunder ✨#
Saviez-vous que vous pouvez ajouter une touche de magie à vos classes Python ? 🧙♂️✨ Grâce aux méthodes spéciales, aussi appelées méthodes “dunder” (car elles commencent par des doubles underscores), vous pouvez personnaliser le comportement de vos objets.
Mais qu’est-ce qui rend ces méthodes spéciales ? 🤔 Ce qui est génial, c’est que vous n’avez pas besoin de les invoquer directement ! Elles sont automatiquement appelées par Python lorsqu’un événement correspondant survient. Par exemple, init est déclenchée lorsque vous créez un nouvel objet, et repr est utilisée pour obtenir une représentation lisible de votre objet. 📋
Nous avons déjà rencontré l’une d’elles : init ! Mais il y en a bien d’autres. 🎩
Implémentons maintenant la méthode repr pour que nos objets puissent s’afficher de manière claire et informative.
Cliquez ici pour en apprendre plus
class Hurricane:
def __init__(self, name, category, lon):
self.name = name.upper()
self.category = int(category)
if lon > 180 or lon < -180:
raise ValueError(f'Invalid lon {lon}')
self.lon = lon
def __repr__(self):
return f"<Hurricane {self.name} (cat {self.category})>"
def is_dangerous(self):
return self.category > 1
f = Hurricane('florence', 4, -46)
f
<Hurricane FLORENCE (cat 4)>
2.5.1.2. Contrôle des versions 🔄#
Le contrôle des versions, c’est comme avoir un superpouvoir pour suivre toutes les modifications de votre code au fil du temps ! 🦸💻 Il permet de revenir à une version précédente si quelque chose tourne mal, ou encore de collaborer facilement avec d’autres développeur·euse·s sans écraser leurs modifications.
Pour cela, Git est votre meilleur allié. ⚔️ C’est un système de contrôle de version distribué qui suit chaque modification et permet à tout le monde de travailler en équipe, tout en gardant le code bien organisé et sécurisé.
Souvenez-vous de GitHub ? 🤔 C’est cette plateforme géniale qui vous permet de git push vos exercices complétés et de garder une copie en ligne de votre code. 📤 Plus besoin de vous soucier de perdre votre travail !
Prêt·e à maîtriser Git et ses commandes ? 🚀
2.5.1.2.1. Initialisation d’un Répertoire Git#
Commencez par créer un nouveau dossier projet. Nous donnons l’exemple sur Colab mais cette même opération peut être réalisée sur votre propre ordinateur en ouvrant un terminal 💻
!mkdir Dossier_Projet
Sur Collab, après avoir navigué sur l’onglet “Fichier” et appuyer sur le bouton “rafraîchir”, le nouveau dossier devrait apparaître.
# Ouvrez votre terminal et naviguez vers le répertoire de votre projet
# %cd change le dossier de référence du projet
%cd /content/Dossier_Projet/
# Montrer où l'on est
!pwd
[Errno 2] No such file or directory: '/content/Dossier_Projet/'
/home/runner/work/geoinformatique-2024/geoinformatique-2024/Geoinformatique_I/IP/Tutoriel_IP
/home/runner/work/geoinformatique-2024/geoinformatique-2024/Geoinformatique_I/IP/Tutoriel_IP
/opt/hostedtoolcache/Python/3.11.10/x64/lib/python3.11/site-packages/IPython/core/magics/osm.py:393: UserWarning: This is now an optional IPython functionality, using bookmarks requires you to install the `pickleshare` library.
bkms = self.shell.db.get('bookmarks', {})
Qu’y a t-il dans le dossier? 🕵
!ls
Dossier_Projet S3_IP_tutoriel.ipynb S5_IP_tutoriel.ipynb
S1_IP_tutoriel.ipynb S3_IP_tutoriel_Bonus.ipynb S6_IP_tutoriel.ipynb
S2_IP_tutoriel.ipynb S4_IP_tutoriel.ipynb pythonobj.json
Rien pour l’instant…
Pour utiliser git dans un projet et suivre l’évolution des fichiers, nous pouvons utiliser la commande git init. Celle-ci crée un dépôt Git dans le dossier où elle est exécutée, en ajoutant un sous-dossier caché appelé .git. Ce dossier stocke toutes les informations nécessaires pour suivre les changements de votre projet.
# Initialisez un nouveau référentiel Git dans le répertoire
!git init
hint: Using 'master' as the name for the initial branch. This default branch name
hint: is subject to change. To configure the initial branch name to use in all
hint: of your new repositories, which will suppress this warning, call:
hint:
hint: git config --global init.defaultBranch <name>
hint:
hint: Names commonly chosen instead of 'master' are 'main', 'trunk' and
hint: 'development'. The just-created branch can be renamed via this command:
hint:
hint: git branch -m <name>
Initialized empty Git repository in /home/runner/work/geoinformatique-2024/geoinformatique-2024/Geoinformatique_I/IP/Tutoriel_IP/.git/
2.5.1.2.2. Ajout de fichiers au suivi de Git#
# Créez quelques fichiers dans votre projet
!touch fichier1.py fichier2.txt
# Listons maintenant les fichiers dans votre dossier
!ls
Dossier_Projet S3_IP_tutoriel_Bonus.ipynb fichier1.py
S1_IP_tutoriel.ipynb S4_IP_tutoriel.ipynb fichier2.txt
S2_IP_tutoriel.ipynb S5_IP_tutoriel.ipynb pythonobj.json
S3_IP_tutoriel.ipynb S6_IP_tutoriel.ipynb
# Ajoutez les fichiers à l'index (zone de préparation)
# i.e., la zone où Git prépare les fichiers avant de les valider dans un commit.
!git add fichier1.py fichier2.txt
# Avant de valider le commit, ajoutons notre identité
# Gardons cette identité anonyme pour l'exemple
!git config --global user.email "you@example.com"
!git config --global user.name "Your Name"
# Validez les changements en créant un commit
!git commit -m "Premier commit, ajout de fichier1.py et fichier2.txt"
[master (root-commit) e0e433e] Premier commit, ajout de fichier1.py et fichier2.txt
2 files changed, 0 insertions(+), 0 deletions(-)
create mode 100644 fichier1.py
create mode 100644 fichier2.txt
2.5.1.2.3. Consultation de l’histoire du projet#
# Affichez l'historique des commits
!git log
commit e0e433eed98365bc2819817b6cb5483ff1ead754 (HEAD -> master)
Author: Your Name <you@example.com>
Date: Mon Oct 21 10:44:34 2024 +0000
Premier commit, ajout de fichier1.py et fichier2.txt
2.5.1.2.4. Modification de fichier et création de Nouveaux commits#
# Modifiez fichier1.py et ajoutez un nouveau fichier fichier3.py
!echo "print('Hello, Git!')" > fichier1.py
!touch fichier3.py
# Ajoutez les modifications à l'index
!git add fichier1.py fichier3.py
# Validez les changements avec un nouveau commit
!git commit -m "Modification de fichier1.py et ajout de fichier3.py"
[master aa32163] Modification de fichier1.py et ajout de fichier3.py
2 files changed, 1 insertion(+)
create mode 100644 fichier3.py
2.5.1.2.5. Branches et fusion (merge) 🌿#
Les branches sont comme des chemins parallèles pour travailler sur différentes fonctionnalités de votre projet, sans affecter la branche principale. 🌱 Vous pouvez développer une nouvelle idée, tester une fonctionnalité, ou corriger un bug sans risquer de tout casser.
Une fois que votre nouvelle fonctionnalité est prête, vous pouvez fusionner votre branche dans la branche principale (souvent appelée master ou main) pour intégrer les changements. 🛠️
Essayons ensemble ! Voici comment vous pouvez créer une nouvelle branche, y apporter des modifications, puis fusionner ces changements dans la branche principale :
# Créez une nouvelle branche
!git branch nouvelle_fonctionnalite
# Changez de branche
!git checkout nouvelle_fonctionnalite
Switched to branch 'nouvelle_fonctionnalite'
# Effectuez des modifications et validez les changements
!echo "print('Nouvelle fonctionnalité ajoutée')" > nouvelle_fonctionnalite.py
!git add nouvelle_fonctionnalite.py
!git commit -m "Ajout de la nouvelle fonctionnalité"
[nouvelle_fonctionnalite 694294d] Ajout de la nouvelle fonctionnalité
1 file changed, 1 insertion(+)
create mode 100644 nouvelle_fonctionnalite.py
# Revenez à la branche principale (master)
!git checkout master
Switched to branch 'master'
# Fusionnez la nouvelle fonctionnalité dans la branche principale
!git merge nouvelle_fonctionnalite
Updating aa32163..694294d
Fast-forward
nouvelle_fonctionnalite.py | 1 +
1 file changed, 1 insertion(+)
create mode 100644 nouvelle_fonctionnalite.py
Il existe de nombreuses autres fonctionnalités Git à explorer, mais ces concepts de base vous donneront une base solide pour travailler avec le contrôle des versions dans vos projets Python
2.5.1.3. Assertion ✅#
Les assertions en Python sont comme des petites vérifications automatiques pour s’assurer que tout fonctionne comme prévu. 🚦 Si la condition que vous spécifiez est vraie, tout roule et le programme continue sans souci. Mais si elle est fausse, Python déclenche une alarme en levant une exception AssertionError. 🚨 Vous pouvez même ajouter un message d’erreur personnalisé pour expliquer ce qui s’est mal passé.
C’est un excellent moyen de valider vos hypothèses pendant l’exécution du programme !
# 'a' est égal à 5. Si la condition est fausse,
# une exception "AssertionErreur" est affichée avec le message spécifié.
a = 5
assert a == 5, "La valeur de 'a' devrait être 5"
print("La condition est vraie, le programme continue.")
La condition est vraie, le programme continue.
Les assertions sont aussi possibles avec les fonctions
# Assertion vérifie si le diviseur ('b') n'est pas égal à zéro avant d'effectuer la division.
# Si 'b' est zéro, une exception "AssertionError" est affichée.
def diviser(a, b):
assert b != 0, "Division par zéro"
return a / b
resultat = diviser(10, 2)
print("Le résultat de la division est :", resultat)
Le résultat de la division est : 5.0
Les assertions sont utilisées pendant le développement et les tests, mais elles peuvent être désactivées en mode production pour améliorer les performances.
# Le module __debug__ est utilisé pour vérifier si les assertions sont activées.
# En mode production (lorsque le script est exécuté avec l'option -O), les assertions sont désactivées.
def fonction_critique(x):
assert x > 0, "La valeur de 'x' doit être positive"
# Le reste du code critique ici
# Désactiver les assertions en mode production
# python -O script.py
Les assertions en Python sont un outil puissant pour vérifier que tout se passe comme prévu dans votre code. 💪 Cependant, elles ne devraient être utilisées que pour des situations qui ne devraient jamais arriver en conditions normales. Si une assertion échoue, c’est que quelque chose est vraiment hors de contrôle !
Pour les erreurs prévues ou les cas spécifiques (comme une entrée utilisateur inattendue), il est préférable d’utiliser des mécanismes de gestion d’erreurs appropriés, comme les blocs try/except. 🛑 Contrairement aux assertions, ces blocs permettent de gérer les erreurs de manière contrôlée, même en production, et d’assurer que votre programme réagit correctement aux situations exceptionnelles.
En résumé : les assertions sont super pour tester vos hypothèses pendant le développement, mais pour tout ce qui pourrait arriver dans la vraie vie, utilisez des solutions adaptées comme try/except. 😉
2.5.1.4. Tests unitaires (“Unit Testing”) 🧪#
Les tests unitaires sont comme un filet de sécurité pour votre code. 🕸️ Ils permettent de vérifier que chaque petit morceau (ou “unité”) de votre programme fonctionne correctement de manière isolée. 🔍 Si tout fonctionne bien à ce niveau, vous pouvez être plus serein·e pour la suite !
En Python, le module unittest est là pour vous fournir un cadre robuste afin d’écrire et d’exécuter ces tests. Avec lui, vous pouvez automatiser la vérification de votre code et vous assurer qu’il est toujours en pleine forme, même après des modifications. ⚙️
Création d’un Fichier à Tester Créez un fichier Python calculatrice.py contenant des fonctions simples à tester.
# Retourner dans l'espace de base
%cd /content/
[Errno 2] No such file or directory: '/content/'
/home/runner/work/geoinformatique-2024/geoinformatique-2024/Geoinformatique_I/IP/Tutoriel_IP
# Ce code crée et écrit le contenu dans le fichier calculatrice.py
with open("calculatrice.py", "w") as fichier:
fichier.write("""
def addition(a, b):
return a + b
def soustraction(a, b):
return a - b
def multiplication(a, b):
return a * b
def division(a, b):
if b == 0:
raise ValueError("Division par zéro")
return a / b
""")
!ls
Dossier_Projet S4_IP_tutoriel.ipynb fichier2.txt
S1_IP_tutoriel.ipynb S5_IP_tutoriel.ipynb fichier3.py
S2_IP_tutoriel.ipynb S6_IP_tutoriel.ipynb nouvelle_fonctionnalite.py
S3_IP_tutoriel.ipynb calculatrice.py pythonobj.json
S3_IP_tutoriel_Bonus.ipynb fichier1.py
✍️ Écriture des Tests Unitaires
Nous allons maintenant créer, grâce à la bibliothèque unittest, un fichier de test nommé test_calculatrice.py, qui servira à tester les fonctions de notre calculatrice.
# Ce code crée et écrit le contenu dans le fichier test_calculatrice.py
with open("test_calculatrice.py", "w") as fichier:
fichier.write("""
import unittest
from calculatrice import addition, soustraction, multiplication, division
class TestCalculatrice(unittest.TestCase):
def test_addition(self):
self.assertEqual(addition(3, 4), 7)
self.assertEqual(addition(-1, 1), 0)
self.assertEqual(addition(0, 0), 0)
def test_soustraction(self):
self.assertEqual(soustraction(5, 2), 3)
self.assertEqual(soustraction(0, 0), 0)
self.assertEqual(soustraction(-1, -1), 0)
def test_multiplication(self):
self.assertEqual(multiplication(2, 3), 6)
self.assertEqual(multiplication(0, 5), 0)
self.assertEqual(multiplication(-2, -2), 4)
def test_division(self):
self.assertEqual(division(8, 4), 2)
self.assertEqual(division(5, 2), 2.5)
with self.assertRaises(ValueError):
division(10, 0)
if __name__ == '__main__':
unittest.main()
""")
Assertion avec Tests unitaires pour vérifier si le code se comporte comme prévu.
# assertion est utilisée comme un test unitaire pour vérifier si la fonction addition fonctionne correctement.
def addition(a, b):
return a + b
# Test unitaire
assert addition(3, 4) == 7, "Test échoué : addition(3, 4) devrait être égal à 7"
print("Test réussi : addition(3, 4) est égal à 7")
Test réussi : addition(3, 4) est égal à 7
Exécution des Tests
Pour exécuter les tests, exécutez le fichier test_calculatrice.py :
!python test_calculatrice.py
....
----------------------------------------------------------------------
Ran 4 tests in 0.000s
OK
Vous devriez voir une sortie indiquant si les tests ont réussi ou échoué. Si tout est correct, vous verrez quelque chose comme :
Les tests unitaires avec unittest sont un moyen efficace de garantir que vos fonctions et classes fonctionnent comme prévu. ✨ Il est fortement recommandé d’écrire des tests unitaires pour chaque composant important de votre code. Cela vous aidera à détecter les erreurs plus tôt et à améliorer la qualité globale de votre logiciel. 🚀
2.5.1.5. Exception 🚨#
Les exceptions en Python sont des événements qui surviennent pendant l’exécution d’un programme et qui interrompent le flux normal des instructions. Elles sont généralement utilisées pour gérer des erreurs ou des situations inattendues, permettant ainsi à votre programme de réagir de manière appropriée aux imprévus. 🚨
Structure d’une Exception
Les exceptions sont généralement constituées d’un type d’exception et éventuellement d’un message d’erreur. Voici à quoi cela ressemble :
try:
# Bloc de code où une exception pourrait se produire
# ...
raise ValueError("Ceci est un message d'erreur")
except ValueError as e:
# Gestion de l'exception
print(f"Une exception de type {type(e).__name__} s'est produite : {e}")
finally:
# Bloc exécuté qu'il y ait eu ou non une exception
print("Le bloc finally est toujours exécuté")
Une exception de type ValueError s'est produite : Ceci est un message d'erreur
Le bloc finally est toujours exécuté
🔍 Types Courants d’Exceptions
Voici quelques-unes des erreurs les plus fréquentes que vous pourriez rencontrer en Python :
ValueError : Une valeur n’est pas correcte pour l’opération demandée. 🚫📊
TypeError : Le type de donnée utilisé n’est pas compatible avec l’opération. ⚠️📐
ZeroDivisionError : Oups, tentative de division par zéro ! ➗❌
FileNotFoundError : Impossible de trouver le fichier demandé. 📂❓
IndexError : Vous essayez d’accéder à un élément en dehors des limites de la liste ou du tableau. 📋🚫
Utilisation du Bloc try...except
Le bloc try...except est utilisé pour capturer et gérer les exceptions afin d’éviter que votre programme ne plante en cas d’erreur. Il permet d’exécuter du code dans la section try, et en cas d’exception, de passer dans la section except pour gérer l’erreur de manière appropriée.
# Exemple 1
try:
nombre = int(input("Entrez un nombre : "))
resultat = 10 / nombre
print("Le résultat est :", resultat)
except ValueError:
print("Erreur : Vous devez entrer un nombre entier.")
except ZeroDivisionError:
print("Erreur : Division par zéro.")
finally:
print("Ce bloc est toujours exécuté, qu'il y ait eu une exception ou non.")
Ce bloc est toujours exécuté, qu'il y ait eu une exception ou non.
---------------------------------------------------------------------------
StdinNotImplementedError Traceback (most recent call last)
Cell In[37], line 3
1 # Exemple 1
2 try:
----> 3 nombre = int(input("Entrez un nombre : "))
4 resultat = 10 / nombre
5 print("Le résultat est :", resultat)
File /opt/hostedtoolcache/Python/3.11.10/x64/lib/python3.11/site-packages/ipykernel/kernelbase.py:1281, in Kernel.raw_input(self, prompt)
1279 if not self._allow_stdin:
1280 msg = "raw_input was called, but this frontend does not support input requests."
-> 1281 raise StdinNotImplementedError(msg)
1282 return self._input_request(
1283 str(prompt),
1284 self._parent_ident["shell"],
1285 self.get_parent("shell"),
1286 password=False,
1287 )
StdinNotImplementedError: raw_input was called, but this frontend does not support input requests.
Utilisation du Bloc try...except...else
Le bloc try...except...else fonctionne de manière similaire à try...except, mais avec une subtilité : le code dans la section else s’exécute uniquement si aucune exception n’a été levée dans le bloc try. Cela permet de séparer clairement la gestion des erreurs et le code qui doit s’exécuter en cas de succès.
# Exemple 2
try:
fichier = open("exemple.txt", "r")
except FileNotFoundError:
print("Erreur : Le fichier n'a pas été trouvé.")
else:
contenu = fichier.read()
print("Contenu du fichier :", contenu)
fichier.close()
Utilisation du Bloc try...except...else...finally
Le bloc try...except...else...finally ajoute une dernière étape : la section finally s’exécute toujours, que ce soit après une exception ou non. C’est idéal pour nettoyer des ressources ou exécuter du code qui doit absolument être exécuté, comme fermer des fichiers ou des connexions, peu importe l’issue de l’opération.
# Exemple 3
try:
fichier = open("exemple.txt", "r")
except FileNotFoundError:
print("Erreur : Le fichier n'a pas été trouvé.")
else:
contenu = fichier.read()
print("Contenu du fichier :", contenu)
fichier.close()
finally:
print("Ce bloc est toujours exécuté, qu'il y ait eu une exception ou non.")
Utilisation de la Clause raise pour Lever une Exception 🚨
La clause raise est utilisée pour lever une exception manuellement dans votre code. 🛑 Cela peut être utile lorsque vous souhaitez signaler qu’une condition particulière n’est pas remplie ou que quelque chose ne va pas. Vous pouvez lever des exceptions Python standard ou créer vos propres exceptions personnalisées pour mieux gérer les situations spécifiques de votre programme.
# Exemple 4
def diviser(a, b):
if b == 0:
raise ValueError("Erreur : Division par zéro.")
return a / b
try:
resultat = diviser(10, 0)
except ValueError as e:
print(f"Une exception de type {type(e).__name__} s'est produite : {e}")
Les exceptions en Python offrent un moyen élégant de gérer les erreurs et les situations inattendues. 🚦 Bien utilisées, elles rendent votre code plus robuste et facilitent la détection ainsi que la gestion des erreurs, vous permettant ainsi d’assurer un bon fonctionnement même face aux imprévus.
2.5.1.6. Débogage 🐞#
Le débogage est une étape clé dans le développement logiciel, c’est là que vous chassez les petits bugs qui se cachent dans votre code ! 🔍 En Python, vous avez à votre disposition des outils puissants comme le module intégré pdb pour comprendre ce qui se passe exactement lors de l’exécution de votre programme.
🛠️ Utilisation du Module pdb
Le module pdb est un super outil de débogage qui vous permet de mettre votre programme en pause à un moment précis et d’inspecter ce qui se passe. 🕵️♂️ Vous pouvez explorer l’état de vos variables, tester des commandes en direct et avancer pas à pas dans le programme pour trouver l’origine du problème.
2.5.1.6.1. Activation du Débogueur 🐛#
Le débogueur sera activé à la ligne où se trouve pdb.set_trace(). Vous pourrez alors utiliser différentes commandes comme :
n(next) : pour passer à la ligne suivantec(continue) : pour continuer l’exécution jusqu’au prochain point d’arrêtp(print) : pour afficher la valeur des variables
import pdb
def exemple():
x = 10
y = 5
z = x + y
pdb.set_trace() # Activation du débogueur
print("Le résultat est :", z)
exemple()
2.5.1.6.2. Exécution avec le Mode Interactif#
Lorsque le débogueur est activé, vous entrez dans un mode interactif où vous pouvez exécuter des commandes. Par exemple :
n: Exécuter la ligne suivante.c: Continuer l’exécution jusqu’à la fin ou jusqu’à la prochaine pause.pvariable : Afficher la valeur d’une variable.q: Quitter le débogueur.
Utilisation de breakpoint (Python 3.7+)
À partir de Python 3.7, vous pouvez utiliser la fonction breakpoint() pour activer le débogueur de manière plus concise.
# Le code s'arrêtera automatiquement à l'endroit où breakpoint() est appelé.
def exemple():
x = 10
y = 5
z = x + y
breakpoint() # Activation du débogueur
print("Le résultat est :", z)
exemple()
Utilisation d’un Environnement de Développement Intégré (IDE)
La plupart des environnements de développement intégrés (IDE) offrent des outils de débogage visuels très pratiques. Par exemple, dans Visual Studio Code, vous pouvez définir des points d’arrêt, suivre l’exécution pas à pas, inspecter les variables en direct et profiter d’autres fonctionnalités avancées de débogage. 🖥️🔍
Le débogage en Python est une compétence indispensable pour identifier et résoudre les erreurs dans votre code. Que vous utilisiez le module pdb en mode console ou les outils visuels d’un IDE, le débogage vous aide à comprendre le comportement de votre programme et à corriger les problèmes efficacement. 🛠️🐞