diff --git a/Modularité/DEBUG.md b/Modularité/DEBUG.md new file mode 100644 index 0000000..ae4101f --- /dev/null +++ b/Modularité/DEBUG.md @@ -0,0 +1,144 @@ +## Débug + +> Savoir débugger, c'est savoir sauver son code. +> Comprendre pourquoi il ne fonctionne pas, traquer, chercher la petite erreur, c'est un pan entier du métier de développeur + +## Introduction + +Après avoir étudié la modularité, il est crucial de comprendre comment détecter, analyser et corriger les erreurs dans notre code. + +Pour cela, nous allons utiliser le débugging. Il va s'agir de revenir sur nos traces, de vérifier chaque ligne de code. +Et dans ce but, nous pourrons bénéficier de l'aide de l'interpréteur Python : celui-ci va nous fournir un message d'erreur qu'on appellera ***exception***. + +Les erreurs, également appelées bugs, peuvent se produire à différents niveaux, y compris les erreurs de syntaxe, les erreurs d'exécution et les erreurs logiques. + + + +### Types d'erreurs en Python + +### Erreurs de syntaxe + +Ce sont des erreurs dans la structure du code, telles que des parenthèses manquantes ou une mauvaise indentation. + +Exemple : + +```python + print("Hello, world" +``` + +### Erreurs d'exécution + +Ces erreurs se produisent lorsque le programme est en cours d'exécution et provoquent l'arrêt du programme. + +Exemple : + + ```python + result = 10 / 0 + print (result) + ``` + +### Erreurs logiques + +Ces erreurs ne provoquent pas l'arrêt du programme, mais produisent des résultats incorrects. + +Exemple : + + ```python + def somme(a, b): + + ​ return a - b # L'erreur est ici, il faut utiliser + au lieu de - + ``` + +------- + +## Techniques de Débugging + +### Lecture attentive du message d'erreur + +Python fournit des messages d'erreur détaillés qui incluent le type d'erreur et l'emplacement où elle s'est produite. Lisez attentivement ces messages pour comprendre la nature du bug. + + + +### Utilisation de `print` pour le débugging + +Ajoutez des instructions `print` pour afficher la valeur des variables à différentes étapes de l'exécution du programme. + +Exemple : + + ```python + def somme(a, b): + + ​ print(f"a = {a}, b = {b}") + + ​ return a + b + ``` + + + +### Utilisation de l'instruction `assert` + + + +Utilisez `assert` pour vérifier que certaines conditions sont vraies à différents points de votre programme. + +Exemple : + + ```python + def somme(a, b): + + ​ assert isinstance(a, int), "a doit être un entier" + + ​ assert isinstance(b, int), "b doit être un entier" + + ​ return a + b + ``` + + + +### Utilisation de l'environnement de débugging intégré (IDE) + + + +Les IDE comme Thonny ou VSCode offrent des outils de débugging intégrés qui permettent de définir des points d'arrêt, d'exécuter le code pas à pas et d'inspecter les valeurs des variables. + + + +### Exemple Pratique de Débugging + +Prenons un exemple de programme avec une erreur logique et voyons comment utiliser les techniques de débugging pour corriger cette erreur. + +Programme avec une erreur : + +```python +def moyenne(liste): + + somme = 0 + + for valeur in liste: + +​ somme += valeur + + return somme / len(liste) + +notes = [15, 18, 12, 9] + +print("La moyenne des notes est :", moyenne(notes)) + + +``` + +-------- + +### Anecdote historique + +Le saviez vous ? Contrairement aux croyances, ce n'est pas Grace Hopper qui a inventé le terme ***bug***, car celui ci était déjà utilisé pour décrire des problèmes de radar durant la seconde guerre mondiale. + +Néanmoins, la postérité aura attribué ce mot à la developpeuse, qui aurait trouvé un insecte dans l'ordinateur de type Mark II. + +------ + +Auteur : Florian Mathieu + +Licence CC BY NC + +Licence Creative Commons
Ce cours est mis à disposition selon les termes de la Licence Creative Commons Attribution - Pas d’Utilisation Commerciale - Partage dans les Mêmes Conditions 4.0 International. \ No newline at end of file diff --git a/Modularité/README.md b/Modularité/README.md new file mode 100644 index 0000000..f746067 --- /dev/null +++ b/Modularité/README.md @@ -0,0 +1,189 @@ +## Modularité + +> Comme vu lors de l'année de première, Python offre une multitude de modules, qui permettent d'utiliser de nombreuses fonctionnalités, d'adapter son programme à un usage précis, mais également de participer aux efforts de la communauté du logiciel libre. + +### Principe + +La modularité est un concept permettant la réutilisation de code au travers des fonctions, facilitant la maintenance, les tests, et donc, un gain de temps, ainsi que de visibilité. Pensez à la construction d’une maison : chaque pièce (module) a une fonction spécifique et peut être construite indépendamment des autres. + +En informatique, les projets peuvent être maintenus par plusieurs personnes et il n'est pas rare qu'un fichier soit modifié par plusieurs personnes. + +C'est pourquoi il est important, lorsque l'on développe, d'être clair et précis tant dans la structuration du programme que dans la documentation. + +Il faudra donc prendre de bonnes habitudes : + +- découper son code en fonctions +- grouper les fonctions par fichier +- regrouper les fonctions dans des classes (que nous verrons plus tard) + +Interessons nous au code python ci dessous. Ici, la structure compte plus que le code en lui même. + +```python +## importations +from math import * +import doctest + +## variables +VALEUR = 25 + +## fonctions +def racine(val): + """ + Renvoie la racine carré d'un nombre. + + :param val: (int) un entier + :return: (float) la racine carré + :CU: type(val) == int && val >= 0 + + example: + >>> racine(VALEUR) + 5.0 + """ + return sqrt(val) + +## programme +print(racine(VALEUR)) + +if __name__=="__main__": + doctest.testmod(verbose=True) +``` + +Chaque bloc est caractérisé par un titre mis en commentaire par ces deux symboles dieses : *##*. + +Avec une nomenclature sous cette forme, on gagne en visibilité et rendra les recherches d'un élément particulier plus rapides. + +------- + +### Programmation modulaire en python + +Python est un langage qui autorise le regroupement de fonctions dans un groupe appelé **classe**. + +- Ces fonctions sont alors appelées **méthodes**. +- On parle alors de **programmation orientée objet**. Nous verrons cela prochainement. + +Pour gagner en visibilité dans un programme, la nomenclature ne suffit pas à elle seule. Une autre manière de gagner du temps consiste à écrire des ***modules*** qui ont une tache spécifique. + +Lorsque l'on programme sous python, nous éditons des fichiers sous un format *.py*. Chacun de ces fichiers python est appelé **module**. + +- Ces modules peuvent être alors regroupés dans un **package**. + +Intéressons nous au programme vu précédemment : + +```python +## importations +from math import * +import doctest +``` + +Au début du programme, nous avons une partie *import* où l'on ajoute toute les lignes d'importations. Ces dernières permettent de préciser à python que l'on ajoute à notre programme des élément du module **math** ainsi que du module **doctest**. + +Chacun de ces modules a ses propres variables, fonctions et autre éléments. Le module math va donc réaliser des opérations mathématiques comme calculer la racine carrée avec la fonction **sqrt** et le module doctest va s'occuper de réaliser des tests unitaires. + +Dans un TP/Projet, il va être important de faire plusieurs modules, ceci aura plusieurs avantages : + +- des fichiers courts +- répartition du travail facilitée +- plus de visibilité lors d'une recherche d'un bug / d'une erreur + +***Attention*** + +Utiliser **from xxx import *** peut sembler plus simple mais cela vous oblige donc à importer des modules inutiles ou non désirés dans votre code. +Prenez l'habitude de n'importer que les modules utiles pour votre programme. + +-------- + +### Documentation + +Un dernier point très important, c'est la documentation avec ses jeux de tests. + +#### Docstring + +Lorsque l'on utilise un module connu comme **math**, **random** ou encore **tkinter**, il est possible de trouver sa documentation en ligne afin de trouver les informations nous permettant de s'en servir correctement. + +Il existe aussi une documentation que l'on peut récupérer via les modules grace à la fonction *help* : + +```python +import random + +help(random) +``` + +La documentation dans le module ne sert pas de décoration mais permet à celui ou celle (voir vous même ! ) comprendre les spécifications. + +Voyons un exemple de **docstring** d'une fonction : + +```python +def somme(n): + """ + Renvoie la somme des nombres entre 0 à n + + :param n: (int) un nombre entier positif + :return: (int) la somme de 0 à n + :CU: + type(n) == int + n >= 0 + """ + return sum([i for i in range(n+1)]) +``` + +La documentation se trouve toujours au début de la fonction, avant la première ligne de son bloc d'instructions et on y retrouve plusieurs informations : + +- Une phrase qui explique son comportement +- la liste des paramètres avec leur type +- le detail de ce qui est renvoyé avec son type +- les contraintes d'utilisation. + +#### Doctest + +Une bonne documentation comporte 2 parties : + +- la première vu précédemment avec la docstring +- la deuxième avec la doctest + +La doctest consiste à demander à votre interface de programmation python de réaliser des tests afin de vérifier si votre code fonctionne. + +Pour réaliser ces tests unitaires, nous allons avoir besoin du module **doctest**. + +Reprenons notre exemple et ajoutons y notre test : + +```python +import doctest + +def somme(n): + """ + Renvoie la somme des nombres entre 0 à n + + :param n: (int) un nombre entier positif + :return: (int) la somme de 0 à n + :CU: + type(n) == int + n >= 0 + + Exemple: + >>> somme(5) + 15 + >>> somme(-1) + AssertionError: erreur + """ + assert type(n)==int, "erreur" + assert n >= 0, "erreur" + return sum([i for i in range(n+1)]) + +if __name__=="__main__": + doctest.testmod(verbose=True) +``` + +Lors de l'exécution du programme principal, la fonction *testmod* du module **doctest** va parcourir toute les documentations à la recherche de ligne commencant par ```>>>```. + +Une fois les lignes trouvées, testmod va exécuter la ligne en question puis va comparer son résultat avec ce qui a été mis en dessous. + +L'attribut *verbose* de la fonction testmod nous permet de dire à ce dernier de nous parler et de donner le détail des test, par défaut l'attribut est mis à False. + +---------- + +Auteur : Florian Mathieu + +Licence CC BY NC + +Licence Creative Commons
Ce cours est mis à disposition selon les termes de la Licence Creative Commons Attribution - Pas d’Utilisation Commerciale - Partage dans les Mêmes Conditions 4.0 International. + diff --git a/programme_terminale.pdf b/programme_terminale.pdf new file mode 100644 index 0000000..ac25b02 Binary files /dev/null and b/programme_terminale.pdf differ