Sous-programmes
Pourquoi ?
Factoriser du code
Réutiliser du code
Rendre le code plus lisible
Fonctions
>>> n = 3 >>> f = 1 >>> for i in range(1,n+1) : ... f = f*i ... >>> f | >>> n = 5 >>> f = 1 >>> for i in range(1,n+1) : ... f = f*i ... >>> f 120 |
→ Encapsuler le code dans des fonctions ou des procédures
>>> factorielle(3) 6 | >>> factorielle(5) 120 |
Sous-programmes : fonction
Fonction (Algorithmique)
Une fonction est une suite ordonnée d'instructions qui retourne une valeur (bloc d'instructions nommé et paramétré).
Fonction <==> expression
>>> y = sin(x)
Procédure (Algorithmique)
Une procédure est une suite ordonnée d'instructions qui ne retourne pas de valeur (bloc d'instructions nommé et paramétré).
Procédure <==> instruction
>>> print(x, y, z)
Fonction (Python)
Fonction ou Procédure (Algorithmique) <==> Fonction (Python)
def nomDeLaFonction(liste de paramètres):
bloc d'instructions
...
avec nomDeLaFonction :
pas de mots réservés du langage Python
pas de caractères spéciaux ou accentués
par convention, commencer le nom par une minuscule
avec def :
sa ligne se termine par «
:»puis bloc d'instructions indenté
liste des paramètres entre parenthèses (éventuellement vide)
Appel de fonction
>>> nomDeLaFonction(arguments éventuels)
Fonction : les différentes possibilités
Sans paramètre
Avec un paramètre
Avec plusieurs paramètres
« Vraies » fonctions
Avec typage dynamique
Avec valeur par défaut
Appel dans l'ordre que l'on veut
Fonctions imbriquées
une fonction peut être incorporée dans une autre !
Sans paramètre
>>> def table7() :
... n = 1
... while n <11 :
... ... print(n * 7, end =' ')
... ... n = n +1
...
>>> table7()
7 14 21 28 35 42 49 56 63 70
Avec un paramètre (valeur ou variable)
>>> def tableN(base) :
... n = 1
... while n <11 :
... ... print(n * base, end =' ')
... ... n = n +1
...
>>> tableN(7)
7 14 21 28 35 42 49 56 63 70
>>> tableN(5)
5 10 15 20 25 30 35 40 45 50
>>> choix = 13
>>> tableN(choix)
13 26 39 52 65 78 91 104 117 130
Avec plusieurs paramètres
>>> def tableMulti(base,debut,fin) :
... n = debut
... while n <=fin :
... ... print(n * base, end =' ')
... ... n = n +1
...
>>> tableMulti(7,3,5)
21 28 35
>>> t, d, f = 5, 6, 9
>>> tableMulti(t,d,f)
30 35 40 45
« Vraies » fonctions : le « return » !
>>> def cube(w):
... return w*w*w
>>> b = cube(9)
>>> print(b)
729
OU
>>> print(cube(9))
729
OU
>>> cube(9)
729
Avec typage dynamique des variables
>>> def affichageTriple(arg):
... print(arg, arg, arg)
>>> affichageTriple (0)
0 0 0
>>> afficherTriple('zéro')
zéro zéro zéro
>>> afficherTriple([5, 7])
[5, 7] [5, 7] [5, 7]
>>> afficherTriple(6**2)
36 36 36
Avec valeur par défaut
>>> def politesse(nom, vedette ='Monsieur'):
... print("Veuillez agréer ,", vedette, nom, ", mes salutations cordiales.")
>>> politesse('Dupont')
Veuillez agréer , Monsieur Dupont , mes salutations cordiales.
>>> politesse('Durand', 'Mademoiselle')
Veuillez agréer , Mademoiselle Durand , mes salutations cordiales.
Paramètres sans valeur par défaut en première position
>>> def politesse(vedette ='Monsieur', nom):
Paramètres sans valeur par défaut en première position !
>>> def politesse(vedette ='Monsieur', nom):
→ ERREUR !
Appel dans l'ordre que l'on veut <==> arguments avec étiquettes
>>> def politesse(nom='Toto', vedette='Monsieur'):
... print("Veuillez agréer ,", vedette, nom, ", mes salutations cordiales.")
>>> politesse(nom='Durand', vedette='Mademoiselle')
Veuillez agréer , Mademoiselle Durand , mes salutations cordiales.
>>> politesse(vedette='Mademoiselle', nom='Durand')
Veuillez agréer , Mademoiselle Durand , mes salutations cordiales.
>>> politesse()
Veuillez agréer , Monsieur Toto , mes salutations cordiales.
Fonction et variables
Selon l'endroit ou vous utilisez pour la première fois une variable vous la déclarez de manière locale a une fonction, ou bien de manière globale.
Ceci va faire varier les endroits a partir desquels vous allez pouvoir accéder a la variable.
Variables locales
>>> def tableN(base) :
... n = 1
... while n < 11 :
... ... print(n * base, end =' ')
... ... n = n +1
...
→ Inaccessibles hors de la fonction !
>>> print(base)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'base' is not defined
Variables globales
>>> d, f = 1, 10
>>> def tableN(base) :
... n = d
... while n < f :
... ... print(n * base, end =' ')
... ... n = n +1
...
variables visibles dans la fonction
mais contenu non modifiable...
→ à éviter autant que possible !
Fonction : méthodologie
Déroulement en 6 étapes : exemple de la factorielle
Nom : un identificateur suffisamment explicite
Paramètres : la liste des paramètres d'entrée-sortie de l'algorithme
Préconditions : une liste d'expressions booléennes qui précisent les conditions d'application de l'algorithme
Appel : des exemples d'utilisation de l'algorithme avec les résultats attendus
Description : une phrase qui dit ce que fait l'algorithme
Code : la séquence d'instructions nécessaires à la résolution du problème
Nom
Déclaration
def factorielle() :
... return
Utilisation
>>> factorielle()
Paramètres E/S
Déclaration
def factorielle(n) :
... f = 1
... return f
Utilisation
>>> factorielle(3)
1
>>> factorielle('toto')
1
>>> factorielle(-1)
1
Préconditions
Déclaration
def factorielle(n) :
... assert type(n) is int
... assert n >= 0
... f = 1
... return f
Utilisation
>>> factorielle(3)
1
>>> factorielle('toto')
AssertionError :
assert type(n) is int
>>> factorielle(-1)
AssertionError :
assert n >= 0
Appel - jeu de tests
Déclaration
def factorielle(n) :
... """
... >>> for i in range(8) :
... print(factorielle(i),end=' ')
... 1 1 2 6 24 120 720 5040
... """
... assert type(n) is int
... assert n >= 0
... f = 1
... return f
Utilisation
>>> for i in range(8) :
... print(factorielle(i),end='')
...
1
1
1
1
1
1
1
1
Description
Déclaration
def factorielle(n) :
... """
... fonction qui calcule la factorielle : f = n !
... >>> for i in range(8) :
... print(factorielle(i),end=' ')
... 1 1 2 6 24 120 720 5040
... """
... assert type(n) is int
... assert n >= 0
... f = 1
... return f
Code – implémentation
Déclaration
def factorielle(n) :
... """
... fonction qui calcule la factorielle : f = n !
... >>> for i in range(8) :
... print(factorielle(i),end=' ')
... 1 1 2 6 24 120 720 5040
... """
... assert type(n) is int
... assert n >= 0
... f = 1
... for i in range(1,n+1) :
... ... f = f * i
... return f
Utilisation
>>> for i in range(8) :
... print(factorielle(i),end='')
...
1 1 2 6 24 120 720 5040
Fonction : itératif vs récursif (exemple de la factorielle)
Mathématiquement
0! = 1
n! = n * (n − 1)! pour n ≥ 1
Version Itérative
def factorielle(n) :
... u = 1
... for i in range(2,n+1) :
... ... u = u * i
... return u
Version Récursive
def factorielle(n) :
... u = 1
... if n > 1 :
... ... u = n * factorielle(n-1)
... return u
Déroulement de la factorielle (version récursive)
>>> factorielle(5)
(5*factorielle(4))
(5*(4*factorielle(3)))
(5*(4*(3*factorielle(2))))
(5*(4*(3*(2*factorielle(1)))))
(5*(4*(3*(2*1))))
(5*(4*(3*2)))
(5*(4*6))
(5*24)
120
Généralisation
Navigation :