Définition de fonction - Partie 1⚓︎
Les fonctions numériques
Prérequis⚓︎
- On suppose que les structures conditionnelles et répétitives ont déjà été abordées,
- donc la notion de corps d'instructions indentées,
- ainsi que l'utilisation de variables numériques.
Exemple 1
Cet extrait code devrait être compréhensible.
taille_1 = 182
taille_2 = 171
taille_3 = 193
taille_4 = 165
if taille_1 < taille_2:
ecart_1_2 = taille_2 - taille_1
else:
ecart_1_2 = taille_1 - taille_2
if taille_3 < taille_4:
ecart_3_4 = taille_4 - taille_3
else:
ecart_3_4 = taille_3 - taille_4
Si ce n'est pas le cas, voici une Initiation à l'algorithmique
Factorisation de code⚓︎
- Factorisation de code
- C'est l'action de mettre en commun du code et de l'améliorer. Voici deux exemples.
Affectation multiple
On peut remplacer ces trois affectations par une seule multiple.
a = 10
b = 15
c = 18
# est équivalent à
a, b, c = 10, 15, 18
Dessin de carrés
Pour dessiner un carré de côté 120 avec le module turtle
, on peut écrire
from turtle import *
forward(120)
left(90)
forward(120)
left(90)
forward(120)
left(90)
forward(120)
left(90)
On constate que l'on peut factoriser le code avec une boucle
from turtle import *
for i in range(4):
forward(120)
left(90)
Si on demande maintenant de dessiner un carré de côté 120, puis 70, on a deux possibilités
from turtle import *
# Carré de côté 120
for i in range(4):
forward(120)
left(90)
# Carré de côté 70
for i in range(4):
forward(70)
left(90)
from turtle import *
def carre(cote):
"Déssine un carré de côté donné"
for i in range(4):
forward(cote)
left(90)
carre(120)
carre(70)
On peut factoriser du code en créant des fonctions, mais ce n'est pas la seule motivation.
Motivation⚓︎
Il est utile de définir des fonctions.
- Pour éviter de dupliquer du code, on factorise.
- Et, on peut réutiliser une fonction dans des contextes variés.
- Pour donner plus sens à des étapes lors d'un algorithme.
- Créer et utiliser une fonction est souvent mieux qu'ajouter un commentaire.
- Pour disposer d'outils intérieurement complexes, mais simples à utiliser.
- Vous aimeriez savoir comment sont codées les fonctions
int
,print
?- Non, quand on débute, il ne vaut mieux pas pour débuter !
- Mais, vous êtes content de pouvoir les utiliser.
- Vous aimeriez savoir comment sont codées les fonctions
Exemple 2
a, b, c = 10, 15, 18
x = 7 * a + 8
y = 7 * b + 8
t = 7 * c + 8
- On constate que
x
,y
ett
sont les images dea
,b
etc
par la même fonction. - Nous aimerions pouvoir faire :
a, b, c = 10, 15, 18
x = f(a)
y = f(b)
t = f(c)
- Cela permet aussi de modifier la fonction
f
en un seul endroit, si nécessaire.- Cette pratique évite les bugs ; on ne corrige ou n'améliore le code qu'en un seul endroit.
Définir simplement une fonction⚓︎
À savoir
Pour définir une fonction :
- On commence par le mot clé
def
; pour definition - On donne un nom à la fonction
- On place zéro, un, ou plusieurs paramètres entre parenthèses
- On termine par
:
- On place un corps d'instructions, ce corps est indenté
- On utilise le mot clé
return
pour renvoyer le résultat
Fonction pour l'exemple 2
def f(n):
return 7 * n + 8
def
est au début de la ligne- On a choisit ici le nom
f
- Il y a ici un seul paramètre entre parenthèses
- On n'a pas oublié, à la fin de la ligne, le caractère
:
- Il y a ici une ligne indentée de 4 espaces, c'est le corps de la fonction
- On renvoie l'expression
7 * n + 8
Fonction pour l'exemple 1
def ecart(taille_1, taille_2):
if taille_1 < taille_2:
return taille_2 - taille_1
else:
return taille_2 - taille_1
def
est au début de la ligne- On a choisit ici le nom
f
- Il y a ici un deux paramètres entre parenthèses
- On n'a pas oublié, à la fin de la ligne, le caractère
:
- Il y a ici quatre lignes, le corps de la fonction est globalement indenté de 4 espaces.
- On renvoie une expression suivant le résultat d'un test,
- mais toujours la différence entre le plus grand et le plus petit paramètre
- cette fonction renvoie l'écart entre ses deux paramètres ; un résultat toujours positif.
Cette fonction est très utile pour rendre du code plus clair.
Premières constructions⚓︎
Résoudre les exercices suivants dans l'ordre
TODO : essayer de les mettre dans un seul e-nsi/pratique ; c'est peut-être mieux. (@all : question ???)
Bravo
Vous savez définir des fonctions simples.
La suite sera plus délicate.
Les deux scripts suivants sont-ils équivalents ?
- Les deux fonctions renvoient le même résultat.
- Dans le script 2, une variable
y
est utilisée.
def f(n):
# Calcul direct
return 7 * n + 8
x, y, z = 0, 1, 2
print(x, y, z)
print(f(x), f(y), f(z))
print(x, y, z)
def f(n):
y = 7 * n + 8
return y
x, y, z = 0, 1, 2
print(x, y, z)
print(f(x), f(y), f(z))
print(x, y, z)
0 1 2
8 15 22
0 1 2
On constate que le sortie est exactement la même alors que le second script « modifie une variable y
».
- Donc la « variable
y
initiale » n'a pas été modifiée... - Nous allons expliquer ce phénomène qui est normal et salutaire.
Normal et salutaire
from inconnu import f
x, y, z = 0, 1, 2
print(x, y, z)
print(f(x), f(y), f(z))
print(x, y, z)
- Nous ne voulons pas que l'expression en surbrillance modifie nos variables si par hasard la fonction
f
d'un moduleinconnu
comportait une modification de variablex
,y
ouz
. - Nous souhaitons que si
f
utilise et modifie des variables, que ce soit en local, et sans conséquences globales.
Il y a donc une différence entre
- les variables globales du script,
- les variables locales du script.
Nous aborderons cette subtilité dans
Définition de fonction - partie 2
- On aborde un peu les variables locales et locales.