fonctions python

Identification

Infoforall

5 - Fonctions et variables


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, int est une fonction ...

Il s'agit juste d'un premier contact. Les fonctions vont être vues sur plusieurs activités.

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. Nous allons ici surtout voir comment fonctions et variables interagissent.

Commençons par vous montrer ce qu'on peut faire assez facilement avec les fonctions (et qui peut s'avérer impossible ou presque sans leur intervention ):

animation d'introduction

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

Le mini-projet lié à cette activité vous permettra de vous appropier ce petit programme et vous parviendrez même à le modifier.

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 :

Sans fonction, difficile de réaliser ceci...

Logiciel nécessaire pour l'activité : Python 3

Evaluation ✎ : questions 08-18

Résumé : Version HTML ou fond blanc ou ou PDF (couleur ou gris)

1 - Premieres déclarations de fonctions

Voici un programme contenant deux fonctions nommées fois2 et plus2.

1 2 3 4 5 6 7
def fois2(x) : resultat = x * 2 return resultat def plus2(x) : resultat = x + 2 return resultat

C'est l'indentation vers la droite qui permet à Python de comprendre quelles instructions appartiennent à la fonction. Il faut donc placer une tabulation ou 4 espaces de suite pour savoir qu’elles sont les instructions rattachées au bloc. De plus, on remarquera qu’on met un double point [ : ] après la première ligne de la déclaration. Sans ce symbole, vous déclenchez une erreur..

01° En regardant le code, que pensez-vous qu'il va se passer lorsqu'on va l'activer ? Les deux fonctions vont-elles réaliser quelque chose ? Une fois que vous pensez avoir la réponse, vérifier en copiant / collant ce script dans Thonny. Lancer. Constatation ?

...CORRECTION...

Il ne va rien se passer.

Par contre, on comprend que l'une doit faire une addition et l'autre une multiplication.

On obtient simplement cela :

résultat dans thonny

Le programme n'a rien fait SAUF déclarer deux nouvelles variables de type function. Vous l'aurez deviné, nous venons de créer deux nouvelles fonctions.

Déclaration de fonction

def fois2(x) :

On remarquera immédiatement que :

  1. On commence la déclaration par le mot-clé réservé def suivi du nom de la fonction.
  2. On a nécessairement des parenthèses.
  3. entre les parenthèses, on fournit le nom des variables (ici  x ) qui vont servir à mémoriser les informations reçues. Ces variables particulières se nomment les paramètres de la fonction.
  4. On finit la ligne par un double point  : , nécessaire également.
  5. Les instructions à réaliser sont indentées (4 espaces ou touche TAB)
  6. On finit par return suivi de la réponse qu'on veut retourner, ici resultat

02° Dans le Shell de Thonny, exécuter les commandes suivantes et observer les réponses. Répondre alors à la question suivante : comment lancer l'exécution d'une fonction ?

>>> plus2 >>> plus2(8) >>> fois2 >>> fois2(20)

...CORRECTION...

On obtient ceci

>>> plus2 <function plus2 at 0x7fd63eabb6a8> >>> plus2(8) 10 >>> fois2 <function fois2 at 0x7fd63eabb730> >>> fois2(20) 40 >>>

Qu'est-ce qu'une fonction ? :

On remarque que lorsqu'on tape juste le nom d'une fonction sans placer les parenthèses, l'interpréteur Python renvoie un identifiant mémoire : celui où sont stockées les lignes de code. Une fonction est donc bien une sorte de variable. Elle ne contient pas une valeur mais du code.

Pour les exécuter, il suffit de mettre le nom et les parenthèses.

03° Peut-on exécuter autant de fois qu'on le veut le code d'une fonction ? Tenter de le vérifier en faisant l'appel d'une des fonctions plusieurs fois de suite.

Nous avons donc un script qui ne fait RIEN sauf déclarer des fonctions. Fonctions qu'on peut ensuite activées à l'aide du Shell. On peut bien entendu également utiliser les fonctions dans le script lui-même. Dans ce cas, on respecte toujours un ordre de présentation :

  1. D'abord la déclaration des fonctions
  2. Ensuite, le code qu'on pourrait nommer programme principal.

04° Pour valider cette première partie, trouvez les résultats que vont renvoyer les fonctions et le résultat qui va s'afficher. Vérifiez ensuite en lançant le code réellement.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
# 1 - - Déclaration des fonctions - - - - def fois2(x) : resultat = x * 2 return resultat def plus2(x) : resultat = x + 2 return resultat # 2 - - Programme principal - - - - - nombre = 3 nombre2 = 5 a = plus2(nombre) b = fois2(a) print(nombre2 + b)

CLIQUEZ ICI POUR VOIR L'ORDRE DES INSTRUCTIONS EXECUTEES :

...CORRECTION...

On obtient ceci

  • Mise en mémoire de la fonction fois2
  • Mise en mémoire de la fonction plus2
  • Affectation de 3 dans nombre
  • Affectation de 5 dans nombre2
  • plus2(nombre) renvoie 5.
  • Affectation de 5 dans a
  • fois2(a) renvoie 10 car a est évaluée à 5.
  • Affectation du 10 dans b
  • Affichage du résultat (5+10=15) mais SANS mise en mémoire : le print provoque un simple affichage.

On retrouve ainsi toutes les choses vues jusqu'à présent.

  • Le code s'exécute séquentiellement
  • On commence par déclarer et mettre en mémoire la fonction fois2 (cela ne l'active pas)
  • Ensuite, on déclare la fonction plus2 (cela ne l'active pas)
  • On lance un appel à plus2 en transmettant 3, et on stocke dans a le résulat, soit 5.
  • On lance un appel à fois2 en transmettant a (donc 5) et on stocke le résultat (10) dans la variable b.
  • On finit avec un appel à la fonction native print. La somme des deux variables devrait afficher 15.

Et pourquoi print en vert si c'est une fonction aussi ? Simplement parce qu'il s'agit d'une fonction native : on ne la déclare pas, elle est intégrée de base à Python. Ca permet de distinger les fonctions rajoutées et les fonctions natives.

2 - Documentation

Nous avons vu qu'en Python, on peut rajouter des commentaires dans le code en utilisant #.

Nous allons maintenant voir qu'on peut (doit) documenter les fonctions de façon à expliquer ce qu'elles font. Aujourd'hui, nous allons simplement voir comment les documenter et comment lire cette documentation. Les activités suivantes les utiliseront de plus en plus.

Commençons par voir comment insérer de la documentation dans les fonctions : c'est simple, il suffit d'insérer la documentation entre ''' et ''' :

Documentation des fonctions

Les documentations des fonctions peuvent être écrites comme on le veut. Il suffit que le lecteur puisse comprendre vos informations.

Il existe néanmoins des normes de descriptions de façon à ce que des documentations automatisées puissent correctement afficher le contenu de votre documentation en HTML ou PDF. Nous utiliserons ici la norme RST permettant de réaliser une documentation compatible avec Sphinx.

  • :param XXX: pour le contenu attendu dans le paramètre nommé ici XXX pour l'exemple
  • :type XXX: pour préciser le type attendu de cette variable
  • :return: pour donner le contenu attendu du retour
  • :rtype: pour donner le type du contenu retourné
  • .. warning:: pour donner des avertissements importants sur l'utilisation ou le comportement de la fonction
  • .. note:: pour les informations moins critiques

05° Modifier la fonction calculer_moyenne pour qu'elle renvoie la réponse attendue précisée dans les commentaires.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
def calculer_moyenne(note1, note2) : '''Renvoie la moyenne des deux notes :param note1: une note dans [0;20] :type note1: int :param note2: une note dans [0;20] :type note2: int :return: la moyenne de note1 et note2 :rtype: float ''' moyenne = 0 return moyenne moy = calculer_moyenne(10, 20) print(moy)

...CORRECTION...

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
def calculer_moyenne(note1, note2) : '''Renvoie la moyenne des deux notes :param note1: une note dans [0;20] :type note1: int :param note2: une note dans [0;20] :type note2: int :return: la moyenne de note1 et note2 :rtype: float ''' moyenne = (note1 + note2) / 2 return moyenne moy = calculer_moyenne(10, 20) print(moy)

La correction est donnée avec un type de documentation respectant RST. Ce n'est pas obligatoire. Vous pouvez voir que cela ne modifie en rien la validité du code Python. La norme de documentation n'est indispensable que si vous voulez utiliser une documentation automatisée.

Il est en réalité inutile de stocker le résultat avant de le renvoyer.

Un code plus concis serait donc 

1 2 3 4 5 6 7 8 9 10 11 12
def calculer_moyenne(note1, note2) : '''Renvoie la moyenne des deux notes ::param note1(int):: une note dans [0;20] ::param note2(int):: une note dans [0;20] :return (float): la moyenne de note1 et note2 ''' return (note1 + note2) / 2 moy = calculer_moyenne(10, 20) print(moy)

06° Utiliser ce nouveau code dans Thonny pour vérifier qu'il fonctionne aussi bien que le précédent.

Nous avons donc vu comment créer la documentation et comment la lire.

Ces deux capacités seront de plus en plus utilisées dans les activités suivantes.

Comprenez bien qu'une documentation de fonction n'est pas simplement un commentaire. Il s'agit réellement d'un outil permettant d'informer les autres utilisateurs de la façon dont il faut utiliser votre fonction. Il s'agit en gros du mode d'emploi de votre fonction. Ces informations doivent être suffisantes pour l'utiliser sans provoquer d'erreurs.

3 - Python interactif

Le code précédent permet donc de créer la fonction et de l'activer directement depuis le programme lui-même.

Mais la fonction est maintenant en mémoire. Autant continuer à l'utiliser non ?

On peut faire de la programmation interactive en rajoutant du code dans le Shell.

07° Vérifiez que la fonction est en mémoire. Tapez alors ceci dans le Shell :

>>> calculer_moyenne(12,14) 13.0 >>> calculer_moyenne(0,14) 7.0 >>> resultat = calculer_moyenne(0,14) >>> resultat 7.0

✎ 08° Compléter la fonction addition pour qu'elle fonctionne correctement. Enregistrer et lancer dans Thonny pour placer cette fonction en mémoire. En faire ensuite appel dans le shell pour vérifier son fonctionnement.

1 2 3 4 5 6 7 8 9
def addition(note1, note2) : '''Renvoie la somme des deux notes ::param note1(int):: une note dans [0;20] ::param note2(int):: une note dans [0;20] :return (int): la somme de note1 et note2 ''' return 0
>>> addition(12,14) 26 >>> resultat = addition(10,14) >>> resultat 24

4 - Vocabulaire : fonction, procédure, routine

Routine, fonction, procédure et méthode

Le mot fonction est utilisée de façon assez générique dans Python. En informatique, il existe des entités qui peuvent être gérées de façon différentes en fonction des langages.

Le vrai mot générique pour parler d'une suite d'instructions mémorisées et à laquelle on peut faire appel de nombreuses fois est le mot routine.

Et il existe plusieurs types de routine :

  • Si la routine ne renvoie rien (pas de return), on parle de procédure.
  • Si la routine renvoie une information vers le programme d'appel, on parle de fonction.
  • Si la routine fait partie d'une Classe d'objets, on parle de méthode.

Python ne fait pas de différence entre procédure et fonction. Les deux routines sont gérées de la même façon. En réalité, les procédures Python retournent une valeur : elles retournent None, c'est à dire "rien" !

09° presentation_luke et presentation_yoda sont-elles des fonctions ou des procédures ?

1 2 3 4 5 6 7 8 9 10 11 12 13
def presentation_yoda() : nom = "Yoda" prenom = "Juste Yoda" profession = "Maitre Jedi tout vert" texte = f"Nom\t{nom}\nPre.\t{prenom}\nPro.\t{profession}" print(texte) def presentation_luke() : nom = "Skywalker" prenom = "Luke" profession = "Jedi sur le retour" texte = f"Nom\t{nom}\nPre.\t{prenom}\nPro.\t{profession}" print(texte)

...CORRECTION...

Ce sont des procédures car elles ne retournent rien. Leurs actions consistent simplement à afficher des choses à l'écran. Certes, on envoie quelque chose vers l'écran. Mais la distinction ne concerne que le renvoie d'information vers le programme d'appel. Et ici, il n'y a pas de return.

f-Strings

Vous remarquerez la présence d'un f devant les strings précédents.

Cela les transforme en f-Strings.

Avec un tel string, on peut noter des noms de variables entre des accolades {...} et lors de la création du string, l'interpéteur Python remplacer les accolades par le contenu de la variable.

1 2 3
def exemple_f() : a = 5 print(f"La variable a contient {a}")

Le résultat dans le Shell :

>>> exemple_f() La variable a contient 5

10° presentation_luke et presentation_yoda sont-elles des fonctions ou des procédures ?

1 2 3 4 5 6 7 8 9 10 11 12 13
def presentation_yoda() : nom = "Yoda" prenom = "Juste Yoda" profession = "Maitre Jedi tout vert" texte = f"Nom\t{nom}\nPre.\t{prenom}\nPro.\t{profession}" return texte def presentation_luke() : nom = "Skywalker" prenom = "Luke" profession = "Jedi sur le retour" texte = f"Nom\t{nom}\nPre.\t{prenom}\nPro.\t{profession}" return texte

...CORRECTION...

Cette fois, ce sont des fonctions : elles vont renvoyer le texte vers le code d'appel. A lui d'en faire ce qu'il veut.

11° Lancer le code suivant qui propose de créer une procédure. On tente néanmoins de stocker son retour (qui n'existe pas) :

1 2 3 4 5 6 7
def exemple_proc() : '''Une procédure comme une autre...''' test = 5 a = exemple_proc() print(a) print(type(a))

Que contient a ?

Quel est le type de ce nouveau contenu ?

...CORRECTION...

La variable fait référence à None.

Il s'agit de la seule valeur possible de ce type de variable : le type None.

5 - Portée des variables locales

Ce point pose souvent problème : comment se fait-il qu'on puisse créer des variables portant le même nom dans les deux fonctions ?

1 2 3 4 5 6 7 8 9 10 11 12 13
def presentation_yoda() : nom = "Yoda" prenom = "Juste Yoda" profession = "Maitre Jedi tout vert" texte = f"Nom\t{nom}\nPre.\t{prenom}\nPro.\t{profession}" return texte def presentation_luke() : nom = "Skywalker" prenom = "Luke" profession = "Jedi sur le retour" texte = f"Nom\t{nom}\nPre.\t{prenom}\nPro.\t{profession}" return texte

Pour comprendre ce point, nous allons modifier un peu les fonctions : nous allons les transformer en simples procédures de test (pas de return) qui ne font qu'afficher les identifiants de ces trois variables à chaque fois qu'on fait appel à la "fonction" !

12° Lancer ce nouveau programme : les variables nommées nom déclarées dans les deux fonctions sont-elles les mêmes ou font-elles références à deux zones mémoires différentes ? Existent-elles en dehors de l'exécution de la fonction ?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
# - - -Déclaration des fonctions - - - - def presentation_yoda() : nom = "Yoda" prenom = "Juste Yoda" profession = "Maitre Jedi tout vert" print(f"Variable d'alias nom, d'id {id(nom)}\tet de contenu {nom}") print(f"Variable d'alias prenom d'id {id(prenom)}\tet de contenu {prenom}") print(f"Variable d'alias profession d'id {id(profession)}\tet de contenu {profession}") def presentation_luke() : nom = "Skywalker" prenom = "Luke" profession = "Jedi sur le retour" print(f"Variable d'alias nom, d'id {id(nom)}\tet de contenu {nom}") print(f"Variable d'alias prenom d'id {id(prenom)}\tet de contenu {prenom}") print(f"Variable d'alias profession d'id {id(profession)}\tet de contenu {profession}")

Puis

>>> presentation_yoda() >>> presentation_luke()

...CORRECTION...

On obtient ceci avec les deux premières instructions :

>>> presentation_yoda() Variable d'alias nom, d'id 2864 et de contenu Yoda Variable d'alias prenom d'id 0336 et de contenu Juste Yoda Variable d'alias profession d'id 0624 et de contenu Maitre Jedi tout vert >>> presentation_luke() Variable d'alias nom, d'id 1488 et de contenu Skywalker Variable d'alias prenom d'id 3032 et de contenu Luke Variable d'alias profession d'id 0984 et de contenu Jedi sur le retour

Les variables portent le même nom mais ne désignent pas la même zone mémoire puisque les id sont différents. Il s'agit donc bien de variables différentes.

13° Utiliser les lignes suivantes dans le Shell, en interactif. Les variables internes aux fonctions existent-elles en dehors de l'exécution de la fonction ?

>>> presentation_yoda() >>> presentation_luke() >>> nom >>> prenom

...CORRECTION...

Les variables déclarées dans les fonctions ne sont lisibles que dans le déroulement de la fonction. Une fois hors de la fonction, Python ne vous donne pas accès à ces variables locales. Il fait d'ailleurs disparaître la liaison rapidement pour ne pas encombrer la mémoire. Cette fonction se nomme poétiquement Garbage Collector en anglais ou Ramasse-miettes en français.

>>> nom Traceback (most recent call last): File "<pyshell>", line 1, in <module> NameError: name 'nom' is not defined >>> prenom Traceback (most recent call last): File "<pyshell>", line 1, in <module> NameError: name 'prenom' is not defined
Espace des noms, le retour

La notion d'espace des noms disposant d'une portée limitée nous permet de ne pas trop nous soucier des noms des variables dans le reste du problème puisque les noms des variables locales dans les fonctions ne peuvent pas être en conflit. Si tout le programme où presque est composé de fonctions qu'on appelle, plusieurs personnes peuvent travailler sur des fonctions différentes sans craindre d'utiliser un nom de variables déjà pris par un autre.

Sans cette notion d'espace des noms, nous devrions regarder le nom de toutes les variables déjà utilisées de façon à garantir qu'on ne va pas écraser le contenu d'une variable qui existe déjà !

Le point important d'une variable est donc la zone mémoire à laquelle elle est liée, pas son nom.

visualisation des id-mémoires

Comment faire alors pour ne pas s'embrouiller ? Le plus simple au début est de lire dans sa tête le nom d'une variable en complétant son nom avec son propriétaire : prenom-de-presentation_luke est beaucoup plus explicite que simplement prenom non ? Dans quelques jours, la notion sera clairement acquise et vous n'aurez plus à rajouter mentalement ces compléments d'information.

Pour la fin de l'activité, je vais néanmoins utiliser cette façon de faire.

Autre chose à bien comprendre : L'espace des noms d'une fonction est détruit dès que la fonction est terminée.. On voit bien que les variables nom-de-presentation_luke et nom-de-presentation_yoda n'ont plus d'existence après l'exécution des fonctions puisque le Shell déclare une erreur lorsqu'on demande à en voir le contenu :

On obtient ceci

>>> presentation_yoda() Variable d'alias nom, d'id 2864 et de contenu Yoda Variable d'alias prenom d'id 0336 et de contenu Juste Yoda Variable d'alias profession d'id 0624 et de contenu Maitre Jedi tout vert >>> presentation_luke() Variable d'alias nom, d'id 1488 et de contenu Skywalker Variable d'alias prenom d'id 3032 et de contenu Luke Variable d'alias profession d'id 0984 et de contenu Jedi sur le retour >>> nom Traceback (most recent call last): File "<pyshell>", line 1, in <module> NameError: name 'nom' is not defined >>> prenom Traceback (most recent call last): File "<pyshell>", line 1, in <module> NameError: name 'prenom' is not defined

Pour vous aider un peu plus à visualiser tout cela, nous allons utiliser un outil en ligne bien pratique : http://pythontutor.com.

14° Partir sur Python Tutor et choisir Visualize your code and get live help now.

  • Rentrer le code fourni ci-dessous.
  • Cliquez sur Visualize Execution
  • Cliquez sur Forward (en avant, vers l'avant...) pour visualiser la création/desctruction des variables au cours de l'exécution du programme.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
# - - -Déclaration des fonctions - - - - def presentation_yoda() : nom = "Yoda" prenom = "Juste Yoda" profession = "Maitre Jedi tout vert" print(f"Variable d'alias nom, d'id {id(nom)}\tet de contenu {nom}") print(f"Variable d'alias prenom d'id {id(prenom)}\tet de contenu {prenom}") print(f"Variable d'alias profession d'id {id(profession)}\tet de contenu {profession}") def presentation_luke() : nom = "Skywalker" prenom = "Luke" profession = "Jedi sur le retour" print(f"Variable d'alias nom, d'id {id(nom)}\tet de contenu {nom}") print(f"Variable d'alias prenom d'id {id(prenom)}\tet de contenu {prenom}") print(f"Variable d'alias profession d'id {id(profession)}\tet de contenu {profession}") # - - - Programme principal - - - - - - - - - presentation_yoda() presentation_luke()

15° Vous avez ci-dessous une copie d'écran obtenu sur Python Tutor. Le contenu mémoire est celui obtenu pendant l'appel de la procédure presentation_luke juste avant l'exécution de la ligne 16. Quelles sont les variables globales en mémoire ? Quelles sont les variables locales de la fonction actuellement en mémoire ?

visualisation des id-mémoires

...CORRECTION...

On voit clairement sur l'image :

  • Deux variables globales dans le corps du programme : les deux noms des procédures, presentation_yoda et presentation_luke
  • Deux variables locales à la fonction presentation_luke : nom et prenom.

6 - Paramètres

Il reste une question : comment se comportent les variables qui servent à stocker ce qu'on envoie aux fonctions, les paramètres.

16° Voici une procédure paramétrée. Elle ne fait que gérer un affichage, elle ne renvoie donc rien vers le programme.

Que contient nom lors du premier appel, celui de la ligne 9 ?

Que contient nom lors du premier appel, celui de la ligne 10 ?

1 2 3 4 5 6 7 8 9 10
# - - -Déclaration des fonctions - - - - def presentation(nom, prenom, profession) : print(f"Variable d'alias nom, d'id {id(nom)}\tet de contenu {nom}") print(f"Variable d'alias prenom d'id {id(prenom)}\tet de contenu {prenom}") print(f"Variable d'alias profession d'id {id(profession)}\tet de contenu {profession}") # - - - Programme principal - - - - - - - - - presentation("Yoda", "Juste Yoda", "Maitre Jedi tout vert") presentation("Skywalker", "Luke", "Jedi sur le retour")

...CORRECTION...

Ligne 9 : on lance l'appel en affectant "Yoda" dans nom.

Ligne 10 : on lance l'appel en affectant "Skywalker" dans nom.

Et voici la dernière question : les paramètres sont-ils stockés dans la même zone mémoire à chaque fois qu'on lance une fonction ou une procédure ?

17° Utiliser le programme ci-dessus. Observer les affichages pour répondre à la question suivante : les paramètres sont-ils toujours stockés à la même adresse-mémoire à chaque fois qu'on lance une fonction ou une procédure ?

...CORRECTION...

Variable d'alias nom, d'id 140064355898400 et de contenu Yoda Variable d'alias prenom d'id 140064355884976 et de contenu Juste Yoda Variable d'alias profession d'id 140064355927000 et de contenu Maitre Jedi tout vert Variable d'alias nom, d'id 140064355884912 et de contenu Skywalker Variable d'alias prenom d'id 140064355898456 et de contenu Luke Variable d'alias profession d'id 140064355927072 et de contenu Jedi sur le retour

On voit donc que les paramètres sont bien des variables locales qui récupèrent et stockent ce qu'on envoie à la fonction lors de l'appel.

Portée des variables locales

Si on résume la portée des variables locales en image, ça donne ceci :

portee-variable-locale

Les paramètres sont bien des variables locales comme les autres si ce n'est qu'on les affecte avec les valeurs transmises lors de l'appel de la fonction.

✎ 18° Expliquer le plus clairement possible le contenu final de reponse. Le mieux est de faire cela étape par étape.

1 2 3 4 5 6 7 8 9 10
def question_finale(x, y) : a = x + 10*y b = calcul_bizarre(a) return a def calcul_bizarre(z) : a = 2 return z*a reponse = question_finale(4,10)

C'est tout en terme de connaissance sur les fonctions pour aujourd'hui. Si on récapitule, nous avons vu :

  • comment déclarer une fonction
  • la différence entre fonction et procédure
  • la notion de variables locales aux fonctions

Activité publiée le 28 08 2019
Dernière modification : 19 07 2020
Auteur : ows. h.