Python 11 : LES FONCTIONS - LES BASES

Nous allons voir un aspect fondamental de la programmation : la possibilité d'insérer des mini-programmes dans les programmes de façon à créer de nouvelles actions. Vous avez déjà utilisé de nombreuses fois les fonctions. Lesquelles ? print est une fonction, input est une fonction, le resize de Pillow sur les objets-image est une fonction, chr et ord sont des fonctions qui font le lien entre un caractère et sa valeur UNICODE...

Mais nous allons voir aujourd'hui comment créer vos propres fonctions si l'action que vous voulez effectuer n'est pas gérée par l'une des innombrables fonctions ou méthodes de Python.

Commençons par vous montrer ce qu'on peut faire de très basique avec les fonctions :

Téléchargez le code à l'aide de l'image et lancez le. Nous obtenons une animation.

Autre chose réalisable : un système réactif. Ici, on reprend l'idée du Simon pour obtenir un système qui réagit aux clics de souris :

1 - Premieres fonctions créées : les procédures

Une fonction est un ensemble d'instructions qui seront effectuées lorsqu'on va appeler la fonction. Aucune ligne de code de la fonction ne sera exécutée tant que la fonction n'aura pas été rendue active par son appel. Un petit exemple pour la forme. Il permet d'afficher les caractéristiques d'un personnage :

01° Tester le bouton puis exécuter réellement le code. Que constatez-vous de nouveau avec d'aller plus loin ?

Comme on utilise la tabulation, n'oubliez pas d'indiquer à Notepad++ d'afficher les symboles spéciaux que sont le tabulations.

Et voici l'explication de ce programme ligne par ligne :

Point important : lorsque vous voulez utiliser la fonction, il ne faut pas juste donner son nom : il faut rajouter les parenthèses après son nom. Il faut donc utiliser test_fonction().

On peut donc utiliser de telles fonctions pour effectuer des tâches répétitives (et exactement identiques) qu'on devrait taper sinon à plusieurs endroits dans le code. On notera que si on devait les faire à la suite directe les unes des autres, les boucles FOR ou WHILE conviennent également.

Et si on veut faire des choses un peu différentes ? On peut aussi ?

Oui, on peut transmettre des arguments (des données) aux fonctions de façon à ce qu'elles utilisent ces contenus venant de l'extérieur. Lors de la déclaration de la fonction, il suffit de placer entre les parenthèses les variables nommées paramètres qui devront récupérer les arguments envoyés.

On devra maintenant fournir les données lors de l'appel de test_fonction : j'ai nommé mon premier paramètre sChaine1 car je veux que ce paramètre soit un String : je veux l'afficher. Si ce n'est pas un string, ça risque de poser problème. C'est pourquoi j'ai pris la peine de placer un s devant le nom : ça me sert de pense-bête.

Pour faire appel à la fonction dans le programme, il faut taper par exemple :

02° Modifier test_fonction comme ci-dessus et en faire l'appel deux fois avec des arguments (valeurs transmises) différents. Par exemple :

Alors, ça fonctionne comment ?

C'est relativement simple : lors du premier appel, on envoie les valeurs suivantes dans l'ordre :

1. L'argument "Yoda" va donc être relié au paramètre de réception sChaine1.
2. L'argument "Juste Yoda" va donc être relié au paramètre de réception sChaine2.
3. L'argument "Maitre Jedi, un peu vert." va donc être relié au paramètre de réception sChaine3.

Vous avez ci-dessous une animation permettant de voir l'affectation successives des 3 paramètres (les 3 boites bleues) :

C'est donc comme si on avait tapé en début de fonction :

Puis, ceci lors du deuxième appel :

L'intérêt, c'est que cette affectation va se faire automatiquement en fonction des arguments fournis lors de l'apppel de la fonction.

03° Faire l'appel de test_fonction(8,"R2D2","Robot").

Vous devriez obtenir quelque chose comme :

Le code utilisé est :

Donc, si vous voulez un code solide, il faudra penser à utiliser regulièrement les blocs try: expect: que nous avons vu lors de l'activité TANT QUE et FOR NOMINATIF.

04° Créer une fonction fois_trois(x) qui possède un seul paramètre et qui effectue print(3*x) avec la donnée(argument) fournie. Dans le corps du programme, en faire l'appel en donnant 10 puis "10" en paramètre.

Vous devriez voir que cette fois, votre fonction accepte plusieurs types de paramètres.

Voilà l'affichage que vous devriez obtenir :

05° On veut créer une fonction déclarée ainsi def affine(a,x,b): qui affiche le calcul suivant a*x+b à l'aide d'un print. Créer la fonction. En faire l'appel en utilisant affine(2,10,4). Que vaut a pendant l'appel ? x ? b ? Vous devriez obtenir et afficher 24 puisque 2*10+4 = 24.

06° Modifier le programme principal (mais pas votre définition de fonction), pour afficher les valeurs de f(x)= 2x+4 pour x variant de 1 à 3.

07° Idem avec x variant de 1 à 100. Une boucle FOR sera nécessaire cette fois.

2 - Le module Turtle

Pour illustrer visuellement l'intêret des fonctions, nous allons utiliser un nouveau module de Python : le module turtle qui permet de réaliser très facilement des dessins vectoriels.

08° Voilà un programme qui uilise turtle pour dessiner un trait de 50 pixels, tourner à droite à 90° puis tracer un second trait de 50 pixels.

09° Créer une fonction def carre(): qui permet de créer un carré.

Voici quelques autres méthodes qu'on peut appliquer aux objets de classe Turtle, qu'on crée à l'aide de mon_objet = turtle.Turtle().

Pour reculer : mon_objet.backward(50) permet de reculer de 50.

Pour tourner à gauche : mon_objet.left(45) permet de tourner de 45° à gauche.

Pour aller faire un mouvement linéaire jusqu'au point de coordonnées (x,y) : mon_objet.setpostion(x,y).

Pour faire un mouvement horizontal jusqu'à atteindre la valeur donnée en x : mon_objet.setx(x).

Pour faire un mouvement vertical jusqu'à atteindre la valeur donnée en y : mon_objet.sety(y).

Pour revenir au point d'origine : mon_objet.home().

Pour dessiner un cercle de rayon x : mon_objet.circle(x).

Pour dessiner un arc de cercle d'angle a et de rayon x : mon_objet.circle(x,a).

Pour tracer des polygones de "rayon" x possèdant y côtés : mon_objet.circle(x,360,y).

Pour placer un point de rayon x et de couleur précise : mon_objet.dot(x,"red").

Pour modifier la vitesse x, x variant de 1 à 10 : mon_objet.speed(x), x=0 veut dire pas d'animation.

Pour lever la pointe du crayon : mon_objet.penup().

Pour abaisser la pointe du crayon : mon_objet.pendown().

Pour avoir un mode RGB allant de 0 à 255 plutot que de 0.0 à 1.0 : trt.colormode(255).

Pour changer la couleur du crayon : mon_objet.pencolor("red") ou mon_objet.pencolor((200,100,50)).

Cela nous suffira mais vous pouvez aller voir la documentation Python pour voir ce que le module peut faire d'autre : PYTHON.

Voilà une solution possible pour la fonction carre :

10° Créer une fonction avanceDe100 qui permet d'avancer de 100 sans rien dessiner. Utiliser ensuite cette fonction pour dessiner un carré, avancer de 100 sans dessiner et dessiner un second carré. Pensez à bien utiliser les différentes fonctions données ci-dessus. Remarque : ce sont des méthodes en réalité, ces fonctions ne peuvent s'appliquer qu'à des objets Turtle.

11° Avec la méthode circle, créer une fonction cercle pour dessiner des cercles de 25 de rayon. Utiliser la fonction dans le programme principal pour aller au bon endroit (méthode setposition(x,y) ) et dessiner 3 cercles au dessus des 3 carrés.

Pas mal avec quelques lignes de codes, non ? Comme c'est votre premier vrai contact avec la création de fonctions, voilà un corrigé possible :

Mais, on peut encore faire mieux : on peut utiliser une fonction dans une autre fonction. Ainsi, je peux créer une fonction les3carres qui va contenir l'appel aux fonctions carre et avanceDe100.

12° Tester le code suivant puis compléter la fonction les3cercles pour que le programme donne le même résultat que précédemment.

13° Modifier les codes des fonctions carre et cercle qui seront transformées en fonction avec paramètre : carre(longueur) et cercle(rayon) où longueur et rayon seront les paramètres du côté du carré ou de rayon du cercle. Créez des carrés de côté 25, 35 et 45. Idem pour les rayons des cercles.

14° Modifier le code de la fonction carre en utilisant une boucle FOR plutôt que de demander quatre fois la même chose en le tapant manuellement.

Vous pouvez constater que le résultat est le même après modification. C'est la force des fonctions : lorsqu'on les utilise, on doit simplement savoir quels arguments transmettre et avoir une idée du but de la fonction.

Vous n'avez aucunement besoin de connaitre les rouages internes d'une fonction ou d'une méthode pour l'utiliser. Elle peut contenir un code simple ou compliqué sans que vous ayez à vous en soucier. Sauf si c'est vous que l'avez conçue bien entendu.

Fonctions, procédures et méthodes

Voilà la limite des "fonctions basiques" : on ne peut pas utiliser leurs codes pour faire autre chose. Avec votre fonction affine, on ne peut pas récupérer le 24 et refaire un calcul avec lui. Il s'agit uniquement d'un affichage console. Comment faire pour récupérer le résultat ? Et bien, il faut rajouter une ligne de code qui va renvoyer quelque chose vers le programme d'appel.

Comme la fonction ne renvoie ni information ni valeur vers le programme principal, on pourrait la nommmer PROCEDURE.

Si on parvient à faire communiquer la fonction, on la nommera effectivement FONCTION.

Dans certains langages, fonctions et procédures ne se déclarent pas de la même manière. Ce n'est pas le cas de Python. C'est donc la dernière fois que nous noterons ici le mot procédure.

Et les méthodes ? Il s'agit tout simplement du nom qu'on donne à une fonction appartenant à une classe d'objets et pouvant donc agir sur un objet. La plupart du temps, elles sont utilisées sous la forme objet.methode(argument). Vous vous souvenez ?

Nous avons donc vu les fonctions sans retour : les procédures.

Il nous reste à voir les fonctions renvoyant une information vers le programme qui en ont fait l'appel.

3 - Fonctions avec retour d'information

Pour renvoyer ce que pointe une variable reponse dans la partie de code qui a fait appel à la fonction, il suffit d'utiliser le code suivant return reponse si reponse = a*x+b. Mais on pourrait même faire plus court en utilisant directement return a*x+b

Comme vous le voyez, on stocke le résultat de la fonction (qu'elle renvoie avec le return) dans une variable f1 pour garder le résultat en mémoire.

15° Avant d'utiliser le code, tentez de découvrir ce que doit afficher normalement le code print(f1).

ATTENTION : lorsque la fonction rencontre return, elle calcule le résultat et sort ensuite du codage de la fonction : c'est comme un break : le reste du code ne sera pas analysé.

On peut également donner le contenu d'une variable comme argument : vous n'êtes pas obligé de donner une valeur en "dur" ce qui est très pratique.

16° Et ce code, que renvoie-t-il ? Faire le calcul à la main puis lancer le programme pour vérifier.

4 - Importation de modules de fonctions

Nous avons déjà vu de nombreuses bibliothèques (ou modules). Par les importer, il suffit d'utiliser l'instruction import :

• Pour importer le module Image de la bibliothèque Pillow : from PIL import Image. On devrait alors utiliser Image.methode pour utiliser une méthode.
• Pour utiliser un alias : from PIL import Image as Img. On devrait alors utiliser Img.methode pour utiliser une méthode.
• Pour importer une fonction spécifique d'un module : from time import time permet d'importer et d'utiliser la fonction time. On pourra alors l'utiliser en tapant simplement time().
• Pour importer tout le contenu d'une bibliothèque ou d'un module, on utilise l'étoile : from math import * permet d'utiliser toutes les fonctions de math :
• Racine carre avec la fonction sqrt : racine_de_x = sqrt(x).
• Sin, cos ... avec la fonction sin : sinus_de_x = sin(x).
• Valeur approximative de pi avec pi : valeur_pi = pi.
• Pour importer une fonction spécifique d'un module : from math import sqrt n'importe que la fonction sqrt
• Pour importer toutes les fonctions d'une bibliothèque en gardant le nom de la bibliothèque lors de l'appel, on utilise : import math permet d'utiliser toutes les fonctions de math :
• Racine carre avec la fonction sqrt : racine_de_x = math.sqrt(x).
• Sin, cos ... avec la fonction sin : sinus_de_x = math.sin(x).
• Valeur approximative de pi avec pi : valeur_pi = math.pi.
• Pour importer toutes les fonctions d'une bibliothèque en changeant le nom de la bibliothèque lors de l'appel, on utilise : import math as m permet d'utiliser toutes les fonctions de math :
• Racine carre avec la fonction sqrt : racine_de_x = m.sqrt(x).
• Sin, cos ... avec la fonction sin : sinus_de_x = m.sin(x).
• Valeur approximative de pi avec pi : valeur_pi = m.pi.

Pour voir toutes les fonctions de la bibliothèque math : DOC PYTHON

Bon, alors autant toujours utiliser, from XXX import * si cela évite d'écrire un truc en plus à chaque fois qu'on utilise une fonction ?

Non. Si vous n'importez qu'un seul module, vous pouvez faire un import total et complet, oui.

Mais si vous faites cela avec deux, trois ou quatre modules, les chances sont grandes qu'ils possèdent des fonctions qui portent le même nom. Et là, bonne chance pour retrouver la bonne !

A titre d'exemple, voici un code qui vous permet d'estimer le temps nécessaire à un ensemble de calcul.

17° Tester le programme ci-dessus. Faire varier le nombre de calculs pour voir l'évolution du temps de calculs avec le nombre de calculs. Vous devriez parvenir à faire cela sans savoir ce que fait exactement la fonction time, c'est l'avantage de tout ceci : on importe et on utilise.

5 - Mini-projet : Des fonctions pour Simon

Nous allons reprendre notre jeu de Simon en lui rajoutant une fonctionnalité : nous voudrions faire briller les carrés lorsqu'on clique dessus.

Commençons par donner le code permettant d'obtenir l'interface (voir la fin de l'activité sur Tkinter) :

Pour rappel (voir la fin de l'activité Tkinter) :

• On crée une fenêtre ayant des dimensions précises avec fen_princ.geometry("600x600")
• On crée des images de classe Img qui servent à créer des objets ImgTk, des images compréhensibles par l'interface Tkinter.
• On crée des widgets Label qui contiendront nos images.
• On positionne les widgets avec la méthode place plutôt que la méthode pack.

18° Tester cette interface visuelle.

Nous avons revu les méthodes geometry et place.

Il nous reste à voir comment changer la couleur des carrés lorsqu'on clique dessus...

Pour cela, nous allons devoir créer un détecteur d'événement :

• un événement correspondant à "je viens de cliquer sur le carré" et
• un événement correspondant à "je n'appuie plus sur le bouton de la souris".

Nous allons rajouter ceci avant la boucle de surveillance de fin :

Vous verrez l'explication précise de ce code dans l'activité GESTION DES EVENEMENTS.

Si on résume, on crée avec la méthode bind deux événements liés au fait d'appuyer sur le bouton de la souris sur imageA ou de relacher le bouton.

On constate que cela devrait lancer l'appel de deux fonctions : changeA et retourA. Il reste donc à les définir :

Comme vous pouvez le voir, il s'agit de deux fonctions très simples qui ne font que changer l'image contenue dans le Label en utilisant la méthode configure. La seule chose étrange est la présence obligatoire de la variable event. Nous verrons à quoi elle sert pendant l'activité sur les événements. Pour l'instant, sachez simplement qu'on doit la placer là sous peine de déclencher une erreur.

19° Rajouter tout ceci dans votre propre code (sans oublier de créer l'image ImgTk nommée carreBleuTk2 dans le corps du programme) et lancer le programme pour voir s'il fonctionne.

Voici un visuel de ce que vous devriez obtenir (le carré bleue est un peu plus clair) :

Et le code correspondant (au cas où vous seriez bloqué sur un point particulier) :

20° Rajouter les lignes nécessaires pour obtenir le même effet sur les 4 carrés colorés.

Voilà. Nous verrons comment gérer cela de façon plus automatisée lors de l'activité sur les événements mais vous avez désormais de quoi vous amusez. Les leçons suivantes traitent désormais de choses plus ou moins indépendantes.

C'est tout pour cette fois. Nous verrons plus tard qu'on peut omettre de déclarer certains arguments d'une fonction (on peut définir des valeurs par défauts), qu'on peut donner des noms aux paramètres et plus encore. Mais rien qu'avec cette simple nouvelle notion de fonction vous avez de quoi multiplier par 10 les possibilités de vos codes.

L'activité suivante est une activité complémentaire à celle-ci : on y traite de la portée des variables dans les fonctions.

Voici la correction de la petite interface au cas où vous bloqueriez (cette solution n'intègre pas les outils non encore vus qui permettront de ne pas écrire 4 fois la même chose puisqu'il y a 4 carrés) :