Différences

Ci-dessous, les différences entre deux révisions de la page.

--- nsi:premiere:definition_fonctions [2021/06/21 10:53] – créée goupillwiki
+++ nsi:premiere:definition_fonctions [2024/08/21 16:21] (Version actuelle) – goupillwiki
@@ Ligne 1: / Ligne 1: @@
-====== Fonctions : Définition et syntaxe Python ======
+====== Fonctions : organiser le code ======
+{{ :nsi:premiere:python:fonctions.eleves.pdf |Fiche élève à imprimer}} -- [[https://diapo.goupill.fr/fonctions_organiser.html|Diaporama]]
 <WRAP tip>On a dit qu'un programme était la traduction d'un algorithme dans un langage de programmation. Ce n'est pas tout à fait exact. Il est plus juste de dire que le programme traduit un **ensemble d'algorithmes**, chaque algorithme réalisant une fonction. Un programme ordinaire est donc constitué de fonction chacune réalisant une petite partie du travail.</WRAP>
 <WRAP important>Quand les programmes sont très simples, il peut paraître inutile de s'embarrasser avec trop d'organisation. Mais notre but est d'apprendre de bonnes méthodes de façon à pouvoir plus tard envisager des programmes plus ambitieux. Le découpage du programme en fonction est alors **INDISPENSABLE**. D'ailleurs, l'essentiel de votre travail de programmation va vite être d'écrire des fonctions ou de les compléter.</WRAP>
+===== Besoin d'organisation =====
+==== Un programme mal écrit ====
+Prenons un programme mal écrit :
+<code python linenums>
+x = int(input())
+y = int(input())
+a = x
+b = y
+while  a % b != 0:
+    r = a % b
+    a = b
+    b = r
+z = b
+print(x//z)
+print(y//z)
+</code>
+  * Celui qui écrit le programme est encore dans son idée, il se comprend peut-être... mais dès qu'il oublie un peu, il ne se comprend plus lui-même !
+  * Pour un autre, la compréhension de ce programme demandera beaucoup d'efforts alors qu'il est très simple.
+**Le programmeur doit faire un effort de lisibilité !**
+==== Mieux nommer les variables ====
+Les variables doivent être mieux nommées pour qu'on sache ce qu'elles signifient. On peut aussi rendre les ''print'' et ''input'' plus explicites.
+<code python linenums>
+num = int(input("Numérateur : "))
+den = int(input("Dénominateur : "))
+a = num
+b = den
+while  a % b != 0:
+    r = a % b
+    a = b
+    b = r
+d = b
+print(f"Fraction réduite : {num//d}/{y//d}");
+</code>
+C'est un peu mieux.
+==== Extraire la fonction ====
+Le programme contient un calcul basé sur le ''while''. On peut l'extraire pour le mettre en évidence.
+<code python linenums>
+def ma_fonction(a,b):
+    while  a % b != 0:
+        r  % b
+        a = b= a
+        b = r
+	return b
+num = int(input("Numérateur : "))
+den = int(input("Dénominateur : "))
+d = ma_fonction(num, den)
+print(f"Fraction réduite : {num//d}/{y//d}");
+</code>
+On peut améliorer les choses en nommant convenablement la fonction.
+<code python linenums>
+def pgcd(a,b):
+    while  a % b != 0:
+        r  % b
+        a = b= a
+        b = r
+	return b
+num = int(input("Numérateur : "))
+den = int(input("Dénominateur : "))
+d = pgcd(num, den)
+print(f"Fraction réduite : {num//d}/{y//d}");
+</code>
+<WRAP tip>
+Conventions pour les noms en plusieurs mots :
+  * ''%%snake_case%%'', la [[https://fr.wikipedia.org/wiki/Snake_case|casse du serpent]] : tout en minuscule, mots séparés par ''%%_%%''. Pour l'exemple ''%%calcule_pgcd%%''. C'est la convention recommandée en Python.
+  * ''%%camelCase%%'', la [[https://fr.wikipedia.org/wiki/Camel_case|casse du chameau]] : changement de mot avec une majuscule. Pour l'exemple ''%%calculePgcd%%''.
+</WRAP>
+=== Signature ===
+<code python linenums:1>
+def pgcd(a,b):
+</code>
+Cette ligne est la définition de la fonction. Elle indique le **nom** de la fonction et elle indique les entrées nécessaires.
+{{ :nsi:premiere:python:pgcd.png?nolink&400 |}}
+=== principal ===
+<code python linenums:8>
+num = int(input("Numérateur : "))
+den = int(input("Dénominateur : "))
+d = pgcd(num, den)
+print(f"Fraction réduite : {num//d}/{y//d}");
+</code>
+Ces lignes constituent la partie principale du programme. À la ligne 10 notamment, on appelle la fonction ''pgcd''. C'est là qu'elle s'exécute.
+<WRAP important>Lors de la définition, avec ''def'', la fonction ne s'exécute pas. Si dans un programme on ne fait que définir des fonctions, alors à l'exécution il ne fera rien.</WRAP>
+=== Documenter la fonction ===
+On appelle **documentation** le bloc de texte que l'on écrit sous la signature :
+<code python linenums>
+def pgcd(a, b):
+    """
+	a: entier
+        b: entier non nul
+	renvoie le pgcd de a, b
+    """
+    while  a % b != 0:
+        r  % b
+        a = b= a
+        b = r
+	return b
+</code>
+Vous **devez** documenter vos fonctions.
+=== Typer ===
+On peut indiquer dans la signature les types des entrées et sorties de la fonction. Ce n'est pas obligatoire et n'est pas exigé en NSI. C'est bien de le faire du moment que cela reste simple.
+<code python linenums>
+def pgcd(a:int,b:int) -> int:
+    ...
+</code>
+==== Modulariser ====
+On peut pousser l'organisation une étape plus loin en plaçant la fonction dans un **module** séparé.
+<WRAP group>
+<WRAP half column>
+<code python linenums>
+# monmodumle.py
+def pgcd(a:int, b:int) -> int:
+    """
+	a: entier
+        b: entier non nul
+	renvoie le pgcd de a, b
+    """
+    while  a % b != 0:
+        r  % b
+        a = b= a
+        b = r
+	return b
+</code>
+</WRAP>
+<WRAP half column>
+<code python linenums>
+# main.py
+from monmodule import pgcd
+num = int(input("Numérateur : "))
+den = int(input("Dénominateur : "))
+d = pgcd(num, den)
+print(f"Fraction réduite : {num//d}/{y//d}");
+</code>
+</WRAP>
+</WRAP>
+Ainsi, le principal est très lisible. On comprend en un coup d'œil ce qu'il fait.
+===== Avantages =====
+Les fonctions ont bien des avantages.
+  * évitent les répétitions
+  * facilitent les tests automatiques
+  * les variables utilisées n'existent que le temps nécessaire.
+  * facilitent le travail à plusieurs
+  * simplifient la structure
+  * modularisation
+==== return !!! ====
+  * Une fonction ne contient **jamais** de ''print''...
+  * **SAUF** si la fonction est fait exprès pour l'affichage.
+  * La sortie d'une fonction est faite par ''return''
+<WRAP tip>
+  * Certaines fonctions peuvent ne rien renvoyer et ne contenir aucun ''return'' (toutefois en Python, une fonction renvoie ''none'' à défaut d'autre chose)
+  * Après l'exécution d'un ''return'', la fonction se termine immédiatement.
+  * Il peut y avoir plusieurs ''return'' dans une fonction. C'est d'ailleurs très pratique.
+</WRAP>
+==== assert comme précondition ====
+''assert'' permet d'indiquer une condition qui **doit** être vérifiée.
+<code python>
+# monmodule.py
+def pgcd(a:int,b:int) -> int:
+    """
+	renvoie le pgcd de a et b
+	"""
+	assert b != 0
+	...
+</code>
+Indique clairement la condition à laquelle la fonction fait son travail correctement.
+==== assert comme test élémentaire ====
+On sait **d'avance** que ''pgcd(15,35) == 7''. On peut s'en servir comme test simple vérifiant que la fonction fait bien son travail.
+<code python>
+# monmodule.py
+def pgcd(a:int,b:int) -> int:
+    """
+	renvoie le pgcd de a et b
+	"""
+	...
+assert pgcd(15,35) == 5
+</code>
+C'est même une bonne idée de multiplier ces tests en essayant les cas bizarres.
+<code python>
+assert pgcd(2*3*3*7*11*23, 3*7*23*17*17*13) == 3*7
+assert pgcd(0,5) == 5
+</code>
+==== Les parenthèses sont signe de fonction ====
+<code python>
+>>> z = 15
+>>> z()
+TypeError: 'int' object is not callable
+</code>
+''%%z%%'' est un nombre entier -- ''%%int%%'' -- mais le fait d'écrire ensuite ''%%z()%%'' fait que Python essaie de comprendre ''%%z%%'' comme une fonction. Un entier ne peut pas être appelé (//called//) comme une fonction, c'est le sens du message d'erreur.