II. Les fonctions¶

Cours¶

Une fonction est un sous-programme qui peut être utilisé plusieurs fois dans le programme principal. Ce sous-programme effectue un traitement précis (une suite d'instructions) sur des données en paramètres.

A. Définition d'une fonction¶

On la définit de la manière suivante (entourer les éléments de syntaxe Python à retenir):

def nom_de_la_fonction(param1, param2,...)    # le nombre de paramètres dépend de la fonction
    instruction1
    instruction2
    ...
    return resultat    # le renvoi d'un résultat est facultatif

On peut le représenter schématiquement de la façon suivante.

graph LR
param1 --> F[nom_de_la_fonction];
  param2 --> F[nom_de_la_fonction];
  F --> resultat

Elle peut avoir de 0 à un nombre n de paramètres, de même pour les valeurs de résultat. Au lieu de paramètres et résultats, on parle aussi d'entrées (les données que l'on a avant de faire un traitement) et de sorties (ce que l'on obtient après le traitement).

Exemples

Pour chacun d'eux, compléter la syntaxe de la fonction en Python.

Algorithme 1

fonction dire_bonjour :
    affiche "bonjour"

Algorithme 2

fonction saluer(nom) :
    affiche "bonjour" + nom

Algorithme 3

fonction carre(x) :
    renvoie x au carré

B. Appel d'une fonction¶

On appelle la fonction de différentes façon, en fonction de son nombre de paramètres et de résultats.

Exemples

Indiquer, dans chaque cas, ce qui sera affiché par l'interpréteur.

Code 1

dire_bonjour()

Code 2

saluer("Dupont")
# autre possibilité
n = "Dupont"
saluer(n)

Code 3

y = carre(5)

TP : Dessiner des formes géométriques avec Turtle¶

Introduction aux fichiers Notebook

L'application Capytale permet d'utiliser des Notebooks : des fichiers qui permettent de faire du Python en ligne. Ils se découpent en plusieurs cellules : soit du texte, soit du code en Python. Pour exécuter les codes, il faut cliquer sur la cellule, puis sur "Exécuter". N'essayez pas de modifier les cellules texte !

Nous allons tracer des figures avec la bibliothèque (ensemble de fonctions déjà écrites) turtle, qui fait déplacer une tortue pour dessiner avec.

Le code suivant trace un segment de 100 px. La fonction forward(dist) fait avancer la tortue d'une distance dist, exprimée en pixels. La fonction done() indique que l'on a terminé et doit toujours être placée à la fin du programme. Cliquer sur le code, puis sur Exécuter.
```
from turtle import *   # on importe une bibliothèque : un ensemble de fonctions, ici pour pouvoir dessiner

forward(100)   # avance la tortue de 100 px
done()         # instruction obligatoire : indique de faire le tracé
```

Les fonctions left(angle) et right(angle) permettent de changer l'orientation de la tortue, de la faire tourner d'un angle angle exprimé en pixels, respectivement sur la gauche ou sur la droite.

Compléter les paramètres des fonctions dans le code suivant pour tracer un carré bleu dont la longueur du côté est de 100 px :

from turtle import *

color("blue")

forward(...)
left(...)
forward(...)
left(...)
forward(...)
left(...)
forward(...)

done()

Ecrire une fonction carre, dessinant un carré de longueur cote, passé en paramètre. Vérifier que votre code trace bien un carré de 100px de côté, grâce à l'appel carre(100).
```
from turtle import *

def carre(cote):
    ... #à compléter

carre(100)
```
On veut pouvoir aussi modifier la couleur du carré. Réecrire une fonction carre prenant cette fois-ci deux paramètres : cote et couleur.
Ajouter un appel à la fonction pour dessiner un troisième carré de longueur de côté 50 et de couleur jaune ("yellow").
```
from turtle import * 

def carre(cote, couleur):
    ... #à compléter

carre(200, "blue")
carre(100, "green")
# ajouter un appel ici
```
On a jusqu'à présent déplacé la tortue de manière relative : en avançant par rapport à là où elle était. On peut aussi lui donner directement des coordonnées auxquelles elle doit se déplacer.

goto(x,y) permet de déplacer la tortue à un point de coordonnées (x,y), exprimées en pixels.

Les fonctions up() et down() permettent respectivement de lever et de baisser le crayon. Quand il est levé, on ne trace pas, et on recommence à tracer quand il est baissé.
Pour tracer des cercles, une fonction circle existe déjà, il suffit de l'appeler. Exécuter le code suivant, traçant un cercle rouge de 100px de rayon sur la gauche de l'écran :
```
from turtle import *

color("red")
up()
goto(-200,0)
down()
circle(100)    #la valeur du rayon est donnée en paramètre

done()
```
Compléter le code suivant pour tracer un premier cercle de rayon 50px à partir de la position (-200,0), et un deuxième à partir de la position (-100,0).
```
from turtle import *

color("red")

up()
goto(-200,0)
down()
circle(...)

#... à compléter

done()
```
On veut pouvoir aussi pouvoir modifier la couleur du cercle avec un seul appel de fonction. Réecrire une fonction circle qui trace un cercle en faisant appel à circle, et définit sa couleur en paramètre. Appeler la fonction pour tracer un cercle de rayon 150 et de couleur orange.
```
from turtle import *

def cercle(rayon, couleur):
    ... #à compléter

# écrire l'appel de la fonction
```
Ecrire un programme traçant des cercles de rayon 100 : un rouge, un bleu et un vert, espacés chacuns de 100 px. Vous utiliserez la fonction cercle définie à la question 7 (elle est connue si vous avez exécuté la cellule précédente).
```
from turtle import *

# c'est parti !
```

Ne pas oublier d'enregistrer votre travail en cliquant sur la disquette en haut à gauche !

TP : Opérations simples avec des fonctions¶

Ecrire une fonction fois_deux(x) qui prend en paramètre un entier ou un flottant x et affiche sa valeur multipliée par 2.
Tester son fonctionnement en l'appelant pour x valant 6.
Modifier cette fonction pour qu'elle n'affiche pas le résultat, mais le renvoie.
Tester son fonctionnement en l'appelant pour x valant 6. Comment récupérer le résultat ?
Ecrire une fonction multiplication(a, b) affichant le produit de a par b.
Tester son fonctionnement en l'appelant sur les valeurs 3 et 4.
Tester son fonctionnement en l'appelant sur les valeurs 3.0 et 4.0. Que remarquez-vous ?
Modifier cette fonction pour qu'elle n'affiche pas le résultat, mais le renvoie.
Faire le même test que dans la question 6, et récupérer le résultat dans une variable.
De la même façon, écrire une fonction addition(a, b) renvoyant la somme de a et de b, et tester son fonctionnement en affectant 3 à a et 4 à b.