Séance 2: Les fonctions

(1)

Séance 2: Les fonctions

Cours d’informatique de BCPST Première année.

(2)

1 Premiers exemples 2

1.1 Syntaxe . . . 2

1.2 Une première fonction . . . 2

1.3 La commande return . . . 3

2 Allons un peu plus loin... 3

2.1 Une fonction comme argument . . . 3

2.2 Des fonctions avec plusieurs arguments . . . 4

2.3 Des fonctions avec plusieurs sorties . . . 4

2.4 Notions d’arguments optionnels . . . 4

2.5 Affichage des variables intermédiaires . . . 4

2.6 Ajout de documentation . . . 5

2.7 Demande à l’utilisateur . . . 5

3 Portée des variables 5 3.1 Notions de variables locales et globales . . . 5

3.2 Commandes globalsetlocals . . . 6

4 Fonctions récursives 7

5 Anticipations possibles avant le TP 8

(3)

Séance 2: Les fonctions

1. Premiers exemples

1.1 Syntaxe

Une fonction est un bloc d’instructions qui a reçu un nom, dont le fonctionnement dépend d’un certain nombre de paramètres (les arguments de la fonction) et qui renvoie un résultat (contrairement aux procédures, qui ne retournent pas de résultat et se contentent d’agir sur l’environnement).

Python connaît déjà quelques fonctions. Taper les opérations suivantes dans l’interprète de commande :

print ("J ' adore l ' informatique ") cos (3*2)

cos est une fonction et print une procédure. Il est facile de faire la distinction en utilisant l’interprète de commande IPython : lorsqu’on applique une fonction, elle un résultat et se trouve donc à la suite du motOut. L’intérêt de définir une fonction est de pouvoir l’utiliser par la suite à l’intérieur d’autres calculs.

Nous pouvons aussi créer de nouvelles fonctions. Pour ce faire, on utilise l’éditeur de scripts, la syntaxe pour créer une fonction est la suivante :

def nomdelafcn ( liste de paramètres ):

bloc

d ' instructions à réaliser return résultat

Après avoir écrit l’instruction finale (celle qui contientreturn), il faut appuyer sur la touche F5 et enregistrer le fichier dans votre répertoire de travail.

Quelques remarques :

• Le nom d’une fonction doit être court mais significatif (éviterf par exemple).

• Le symbole : qui se trouve au bout de la première ligne est discret mais indispensable. Les instructions que l’on trouve en dessous de la première ligne forment ce qu’on appelle le corps de la fonction. Ce corps est constitué des commandes qui sont interprétées au fur et à mesure par Python à chaque fois que l’on fait appel à la fonction.

• Il est crucial de respecter l’indentation, c’est-à-dire le retrait (à droite), par rapport à def, du corps de la fonction. C’est une spécificité du langage Python qui utilise l’indentation pour délimiter le corps de la fonction.

1.2 Une première fonction

Voici un premier exemple qui donne l’aire d’un cercle. On écrit les instructions suivantes dans l’éditeur de scripts :

def ex1 (r ):

import math

aire = math . pi *r*r return( aire )

Après, on appuie sur la touche F5 et enregistre le fichier dans notre répertoire de travail (en le nommant cours2.py par exemple) puis on utilise de nouveau la console :

ex1 (5)

ex1 (6 ,7) # Il faut le bon nombre d ' arguments !

Institut d’Alzon 2021/2022 page 2

(4)

1.3 La commande return

Quelques subtilités à connaître sur la fonction return :

1. Toute fonction a au moins un return... même celle qui ne renvoie rien (elle renvoit None si on veut être précis), elle finit par return().

2. Dans un return, on peut faire du calcul. Cette fonction renvoie par exemple la différence entre deux nombres :

def diff (a ,b ):

return( b -a)

3. Dans un return, on n’a pas nécessairement qu’une seule variable.

def deux (b ):

return( b , 2*b)

4. Dans return, on peut n’avoir que la variable d’entrée. Il s’agit alors d’une fonction qui modifie et renvoie son entrée :

def double (a ):

a *=2 return a

5. Une fonction peut contenir plusieursreturn. Elle se termine au premierreturnévalué. Difficile de faire un exemple actuellement sans faire une boucle :

def abso (x ):

if x >=0:

return(x) return(-x)

Cette fonction est tout simplement la fonction valeur absolue. Vous pouvez la tester en tapant abso(-2.3)etabso(5) dans la console. Avoir plusieursreturnpermet de gagner du temps de processeur, on sort de la fonction dès que l’on a l’information importante.

2. Allons un peu plus loin...

2.1 Une fonction comme argument

Une fonction est une variable comme les autres, elle peut donc être une entrée d’une autre fonction.

Écrire les instructions suivantes dans l’éditeur de scripts : def ex2 (f , a ):

b=f(a )+12 return(b)

Utiliser maintenant la console : ex2 ( ex1 , 5)

ex2 ( sin , 5)

ex2 (5 ,6) # Il faut être cohérent !

(5)

2.2 Des fonctions avec plusieurs arguments

Une fonction peut avoir zéro, un ou plusieurs arguments. La fonction suivante calcule le périmètre d’un rectangle connaissant les longueurs de ses deux côtés :

def peri (a ,b ):

return 2*(a+b)

Une fois que Python a acquis cette fonction, on peut lui demander : peri (3 ,7)

2.3 Des fonctions avec plusieurs sorties

Une fonction peut retourner plusieurs sorties, c’est le cas par exemple si on modifie un peu notre première fonction :

def ex1bis (r ):

import math

aire = math . pi *r*r return( aire , r +10)

Dans la console, on écrit par exemple ex1bis(5) pour constater que cette fonction renvoie deux sorties.

2.4 Notions d’arguments optionnels

Si on tape peri(5) sur la console, Python renvoie :

TypeError: peri () takes exactly 2 arguments (1 given )

On peut constater sur ce dernier exemple qu’une erreur se produit si on ne donne pas exactement le bon nombre d’arguments d’une fonction. Il est possible de modifier ceci en précisant les valeurs par défaut que doivent prendre certains arguments d’une fonction. Ecrire les instructions suivantes dans l’éditeur de scripts :

def peri (a ,b =12):

return 2*(a+b)

Avec cette nouvelle définition, si on oublie de préciser le deuxième paramètre, ce dernier sera pris par défaut comme valant 12. Repasser maintenant dans la console :

peri (5) peri (5 , 12) peri (5 ,7)

2.5 A ffi chage des variables intermédiaires

A l’exception du résultat, les variables qui interviennent dans la fonction ne s’affichent pas. Si l’on souhaite tout de même les voir à l’écran (typiquement pour contrôler le bon déroulement de notre fonction), on peut forcer leur affichage à l’aide de print. Vous pouvez créer cette fonction :

def plusun (z ):

print(z +1) return z

puis écrire ceci dans la console :

(6)

plusun (4) a= plusun (10)

a +3 # Python sait - il bien compter ?

2.6 Ajout de documentation

Il est possible (voire recommandé !) de rajouter une documentation a la fonction, c’est-à-dire une description des arguments et du résultat de la fonction. Cette documentation doit être écrite entre triples guillemets sur la ou les ligne(s) suivant le mot clédef, ce qui donne :

def nomdelafcn ( liste de paramètres ):

""" documentation de la fonction """

bloc d ' instructions

à réaliser return résultat

On obtient ensuite la documentation d’une fonction en tapanthelp(nomdelafcn). On peut reprendre la fonction réelle :

def abso (x ):

""" Donne la valeur aboslue de x """

if x >=0:

Il suffit maintenant de taperhelp(abso)dans la console. On peut essayer aussihelp(cos),help(atan).

2.7 Demande à l’utilisateur

On peut vouloir demander à l’utilisateur explicitement quelque chose. La commande input permet de le faire. La commande input("ma question ?" ) affiche le message "ma question ?" à l’écran (sans passer à la ligne) et attend que l’utilisateur entre une réponse au clavier. On peut alors affecter cette réponse à une variable.

Taper les opérations suivantes dans l’interprète de commande :

anneedenaissance = int(input(" Quel est ton annee de naissance ?"))

" tu as " + str(2021 -int( anneedenaissance )) + " ans ."

On peut alors faire des fonctions où on dit explicitement à l’utilisateur ce qu’on attend de lui : def abso ():

x=float(input(" Rentrez un réel et je vous donnerai sa valeur absolue ")) if x >=0:

3. Portée des variables

3.1 Notions de variables locales et globales

Nous avons déjà introduit dans plusieurs fonctions des variables qui n’étaient pas des paramètres de la fonction. Par exemple, en écrivant les instructions suivantes dans l’éditeur de script, vous créer la

(7)

fonction mensonge et la variablei : i = 42

def mensonge ():

i = 10

print("i vaut " + str(i )) On passe après dans la console :

i

mensonge () i

Une telle variable (la variablei crée dans la fonction mensonge) est dite locale à la fonction. Son nom a peu d’importance, elle n’a rien à voir avec une variable de même nomi existant en dehors de cette fonction. Python crée ces variables locales pour pouvoir exécuter la fonction mais les oublie une fois la fonction terminée. Il est donc impossible d’accéder à une variable locale en dehors de la fonction où elle est définie. Par contre, cela permet une plus grande liberté puisqu’il est alors possible d’utiliser les mêmes noms de variables locales dans des fonctions différentes.

Les variables définies en dehors de toute fonction sont dites globales. Cela signifie que Python connaît les valeurs de ces variables tout au long de votre script et qu’il est donc possible d’y accéder à n’importe quel niveau, c’est-à-dire à l’extérieur ou à l’intérieur d’une fonction. Mais attention, toute modification de cette variable globale effectuée dans le corps d’une fonction n’a d’effet qu’à l’intérieur de la fonction. Une fois sortie de la fonction, la variable globale reprend la valeur qu’elle avait avant la création de la fonction.

Vous pouvez créer cette fonction : def moinsa (z) :

b=z -a return b

puis écrire ceci dans la console : a =2

moinsa (10) b

b =5

moinsa (15) b

Quand on ecritmoinsun(z), on crée une variable localeb. Quand on crée la variable globale ben tapantb= 5 puis qu’on exécute la fonction, cela n’affecte pas la valeur de la variable globaleb.

3.2 Commandes globals et locals

• La commandeglobals()dans la console obligePythonà réciter la liste des variables globales (avec leurs valeurs). On y retrouve ses propres variables mais aussi celles utilisées par Python ou encore celles chargées par l’acquisition de bibliothèques (telle quemath).

(8)

• La commandeglobals, à l’intérieur d’une fonction, permet de créer ou de modifier le contenu d’une variable globale à l’intérieur du bloc d’instructions d’une fonction.

• À l’intérieur d’une fonction, la commandelocals()demande à Python la liste des variables locales (avec leurs valeurs).

Taper ceci dans l’éditeur de script : i = 1

j= 1 def ok ():

global i a =7 b =8

print(locals()) i = 2

j= 2

print("i vaut " + str(i )) puis écrire ceci dans la console :

i a ok () i

j # Il ne se passe pas la même chose pour i et j a

globals() # Il en sait des choses Python !

4. Fonctions récursives

Une fonction récursive est une fonction qui s’appelle elle-même. C’est une notion proche de celle de boucle que l’on verra plus tard. Elle permet d’écrire parfois des programmes de façon plus efficace et plus élégante.

On a déjà vu qu’une fonction pouvait faire intervenir une autre fonction : def ex2 (f , a ):

b=f(a )+12 return(b)

Une fonction récursive s’appelle elle-même. Voici un exemple : def puissdeux (a ):

if a ==0:

return 1 else:

return 2* puissdeux(a-1)

Il est aisée de comprendre que puissdeux(0)est 1, soit 2⁰.puissdeux(1)est le double de puissdeux(0), soit 2 qui est 2¹.puissdeux(2)est le double depuissdeux(1), soit 4 qui est 2². En réitérant ce raisonnement, on comprend que cette fonction prend en entrée un entier naturelaet renvoie 2^a.

(9)

Dans cette fonction, l’exposantadiminue de un à chaque appel. Il faut penser à assurer la terminaison de la fonction avec un cas de base où la fonction répond sans s’appeler. Ici, on sait qu’on renvoie 1 si la valeur d’entrée est 0. Si on oublie le cas de base, la fonction va s’appeler indéfiniment.

La suite (u_n)_n∈Nde Fibonacci est définie paru₀= 1,u₁= 1 et :

Pour tout entier natureln,u_n+2=u_n+u_n+1.

On peut calculer le n-ième terme de cette suite en utilisant une fonction récursive. Voici deux programmes, les deux vérifient le cahier des charges mais l’un des deux est maladroit, essayez de comprendre pourquoi :

def fibo (n ):

if n ==0:

return 1 if n ==1:

return 1

return fibo (n -1)+ fibo (n -2) def fibo2 (n , u1 , u0 ):

if n ==0:

return u0 if n ==1:

return u1

return fibo2 (n -1 , u1 +u0 , u1 )

5. Anticipations possibles avant le TP

Avant le prochain TP, je peux essayer d’écrire ma première fonction et la tester. Par exemple, écrire une fonction prenant en entrée deux réelsaetb et renvoyant la somme des deux. Il est important aussi de comprendre les différentes fonctions exposées dans ce cours et en particulier le concept de fonctions récursives. Je m’assure aussi que j’ai la bibliothèqueturtleen tapant ceci dans la console :

from turtle import *

Si cette bibliothèque n’est pas installée, je connecte mon ordinateur à internet et je tape ceci dans la console :

install turtle

Je tape dans l’éditeur les lignes suivantes et j’observe : from turtle import *

forward (200) left (120) forward (200) left (120) forward (200) left (120) mainloop ()