Deutsch   English   Français   

4. Function

 

 

TU APPRENDS ICI...
 

Les fonctions sont des blocs de programme nommés qui te permettent de mieux structurer tes programmes. Leur utilisation est très importante, car elles évitent de répéter plusieurs fois le même code dans un programme (duplication de code) et permettent de diviser un problème en sous-problèmes plus simples.

 

 

EXEMPLES
 


Example 1: Faire clignoter un feu de circulation en plusieurs couleurs

Un "cycle de clignotement" avec la couleur c comprend les actions suivantes : choisir la couleur, dessiner un cercle rempli de cette couleur, attendre 500 millisecondes, choisir la couleur blanche, redessiner le cercle en blanc (et ainsi l’effacer), puis attendre encore 500 millisecondes.
Tu peux regrouper ce cycle dans une fonction (un bloc nommé) et l’appeler ensuite avec différentes couleurs.

La définition d’une fonction commence par le mot-clé def. , suivi du nom, de parenthèses et de deux points. Les parenthèses peuvent contenir des paramètres (ici c) utilisés dans la fonction. Si aucun paramètre n’est nécessaire, elles restent vides.
Les instructions du corps de la fonction forment un bloc de programme et doivent donc être indentées.

Les définitions de fonctions se placent généralement au début du programme, juste après les lignes d’importation.
Dans le programme principal, la fonction est appelée trois fois avec les valeurs de paramètres "red", "yellow" et "green".

Programme:     

# Gp4a.py
from gpanel import *

def flash(c):
    setColor(c)
    fillCircle(3)
    delay(500)
    setColor("white")
    fillCircle(3.2)
    delay(500)

makeGPanel(-10, 10, -10, 10)
repeat 10:
    flash("red")
    flash("yellow")
    flash("green")
►Copy to clipboard		  




Example 2: Étendre l’ensemble des instructions

Le module GPanel contient déjà de nombreuses fonctions prédéfinies.
En définissant tes propres fonctions, tu peux étendre cet ensemble d’instructions.
Dans cet exemple, tu définis une fonction star(x, y) qui dessine une étoile à l’aide de deux triangles équilatéraux remplis ayant le même centre (x, y).
Dans le programme principal, tu appelles cette fonction plusieurs fois.

Programme:      

# Gp4b.py
from gpanel import *

def star(x, y):
    fillTriangle(x - 0.86, y - 0.5, 
                 x + 0.86, y - 0.5, x, y + 1)
    fillTriangle(x - 0.86, y + 0.5, 
                 x + 0.86, y + 0.5, x, y - 1)
    
makeGPanel(0, 10, 0, 10)
setColor("red")
star(2, 2)
star(5, 7) 
star(7, 4)
►Copy to clipboard		  

 

Example 3: Dessiner des étoiles aléatoires sur un fond bleu (ciel étoilé)

La fonction star() reste la même, mais les positions sont choisies aléatoirement.
Avec bgColor("darkblue"), tu peux définir la couleur de fond de la fenêtre graphique sur bleu foncé.

Programme:      

# Gp4c.py
from gpanel import *
from random import randint

def star(x, y):
    fillTriangle(x - 0.86, y - 0.5, 
                 x + 0.86, y - 0.5, x, y + 1)
    fillTriangle(x - 0.86, y + 0.5, 
                 x + 0.86, y + 0.5, x, y - 1)
    
makeGPanel(0, 25, 0, 25)
bgColor("darkblue")
setColor("yellow")
repeat 30:
    x = randint(3, 22)
    y = randint(3, 22) 
    star(x, y)
►Copy to clipboard		  

 

Example 4: Résoudre les problèmes étape par étape

Cet exemple montre comment résoudre un problème complexe en plusieurs étapes.
Diviser un problème complexe en sous-problèmes simples est un concept essentiel (appelé programmation structurée).
Tu peux t’exercer avec de petits exemples : les fonctions y jouent un rôle central, c’est pourquoi on parle aussi de programmation fonctionnelle ou procédurale.
(En Python, fonctions et procédures sont identiques.)

Pour créer un jardin de fleurs — une tâche relativement complexe — tu définis la fonction flower(), qui dessine une seule fleur. Celle-ci se compose d’une tige droite et d’une fleur dessinée à l’aide de la fonction bloom(). Enfin, la fonction garden(n) , dessine n fleurs à des positions x aléatoires.

Programme:      

# Gp4d.py
from gpanel import *
from random import randint

def bloom():
    setColor("magenta")
    fillCircle(2)
    setColor("yellow")
    fillCircle(1)

def flower(x):
    pos(x, 0)
    lineWidth(3)
    setColor("green")
    line(x, 0, x, 4)
    pos(x, 6)
    bloom()
    
def garden(n):
    repeat n:
        x = randint(0, 30)
        flower(x)    

makeGPanel(-3, 32, -10, 25)
garden(10)
►Copy to clipboard		  

 

 

À RETENIR...
 

Les fonctions te permettent de mieux structurer tes programmes et d’étendre ton ensemble d’instructions.
Le nom d’une fonction commence par une minuscule et peut être choisi librement. Les mots-clés et les lettres accentuées ne sont pas autorisés. Sans appel de fonction, celle-ci ne s’exécute jamais.

 

 

À FAIRE PAR TOI-MÊME
 

1)


u veux que 50 cercles rouges, bleus, verts, jaunes et violets apparaissent à des positions aléatoires.
Définis une fonction colorCircle(c) avec les actions suivantes :

  • définir la couleur sur c
  • définir la position à des coordonnées aléatoires entre 0 et 100
  • dessiner un petit cercle rempli

Dans le programme principal, utilise une boucle repeat 50: et appelle la fonction colorCircle() avec les paramètres "red", "yellow", etc

  

 

2)

Définis une fonction bird(x, y) qui dessine une ligne en forme d’oiseau à la position (x, y).
Dans une fenêtre GPanel(0, 20, 0, 20), utilise les fonctions d’arc arc(2, 30, 120) et arc(2, 150, -120).

  

 

3)

Définis une fonction snowman(x) qui dessine, à la position (x, 0), un bonhomme de neige blanc.
Dans le programme principal, choisis un fond bleu et appelle la fonction plusieurs fois à différentes positions.