Cours FONCTIONS PYTHON 16

FONCTIONS EN PYTHON
I DEFINITION
En Python, une fonction sert à isoler une instruction, ou un bloc d'instructions qui sera repéré par un nom
et pourra être appelé à différents endroits d'un programme pour être exécuté, le plus souvent avec des
arguments, ou paramètres, qui pourront varier selon les appels.
Une fonction peut renvoyer le résultat d'un calcul, qui pourra être utilisé dans le programme (affichage,
stockage dans une variable, utilisation dans une expression…), mais ce n'est pas toujours le cas.
En Python, une fonction peut aussi désigner un simple sous-programme.
Syntaxe de l'appel d'une fonction :
nomfonction(argument1, argument2,…etc)
II UTILISATION DE FONCTIONS PRÉDÉFINIES
Exemples :
-La fonction int appliquée à un flottant ou à une chaîne de caractères représentant l'écriture décimale
d'un entier, renvoie un certain entier
-La fonction print a pour effet d'afficher les valeurs transmises comme arguments dans la console
-Fonctions numériques accessibles directement : cf annexe1 : abs , round , pow …
prennent des arguments de type numérique et renvoient une valeur de type numérique
Fonctions du module math (cf. annexe1)
Elles ne sont pas accessibles directement mais doivent être importées depuis ce module.
Il y a deux manières principales de procéder :
• Si on ne veut utiliser que quelques fonctions, on n'importe que celles dont on a besoin :
from math import sqrt,cos
L'appel se fait alors simplement par le nom de la fonction suivi de ses arguments entre parenthèses:
Ex :
x=sqrt(2)
print(x+cos(3*x))
• Si on doit utiliser un grand nombre de fonctions du module, il vaut mieux importer le module :
import math
Mais dans ce cas, lors de chaque appel, il faut faire précéder le nom de la fonction du préfixe math.
Ex :
x=math.sqrt(2)
print(x+math.cos(3*x))
Pour alléger l'écriture, on choisit en général un alias du module lors de l'importation :
import math as ma
x=ma.sqrt(2)
print(x+ma.cos(3*x))
Attention, dans ce cas on ne peut plus choisir le nom ma pour désigner une variable du programme !
Remarque : on peut en principe également importer toutes les fonctions du module par :
from math import*
L'appel d'une fonction ne nécessite alors aucun préfixe.
Cette méthode est cependant déconseillée, car lourde.
De plus, les différentes bibliothèques de Python contiennent des fonctions qui portent le même nom mais
ont des propriétés différentes. Lorsqu'on utilise une fonction, la présence d'un préfixe devant son nom
permet de savoir de laquelle il s'agit.
De plus, on peut créer ses propres fonctions, et on n'est jamais sûr de ne pas leur donner le nom d'une
autre fonction déjà importée d'un module ou d'une bibliothèque.

Obtention d'aide depuis la console:
Pour obtenir la liste des fonctions du module math : taper dir(math) .
Pour obtenir le contenu du module avec la description des fonctions : taper help(math) .
Pour obtenir par exemple l'aide sur la fonction acos , taper help(math.acos)
III DEFINITION D'UNE FONCTION
On peut définir autant de fonctions que l'on souhaite dans un script Python.
Syntaxe :
def nom(arg1, arg2,…):
bloc
La première ligne est l'en-tête de la définition de la fonction, le bloc (indenté) est le corps de la fonction.
Ne pas oublier les ":" à la fin de l'en-tête !
Si la fonction doit renvoyer des résultats, le bloc contient une instruction de la forme :
return résultat1, résultat2,…
(en général à la fin car cette instruction provoque la sortie du corps de la fonction).
S'il n'y a pas d'instruction return , la fonction revoie None.
Structure d'un script "ordinaire" :
import…
importations diverses éventuelles
def f1(…):
bloc1
def f2(…):
bloc2
définitions des fonctions
instruction1
instruction2
…
bloc principal du programme (ou programme
principal)
On peut aussi créer ses propres modules, qui pourront être importés dans d'autres scripts :
import…
importations diverses éventuelles
def f1(…):
bloc1
def f2(…):
bloc2
définitions des fonctions
L'appel d'une fonction peut apparaître dans une instruction du bloc principal, ou bien dans le corps d'une
autre fonction.
Pour comprendre un script, toujours commencer par lire le bloc principal.
Lors de l'exécution d'un script, ce sont les instructions du bloc principal qui sont exécutées,
sucessivement, dans l'ordre.
L'appel d'une fonction constitue un branchement; lors de l'appel, l'interpréteur laisse en attente le bloc
principal, exécute le corps de la fonction, puis revient aux instructions du bloc principal.
Lors de l'appel d'une fonction, bien préciser tous les arguments (ou paramètres), dans l'ordre, sauf s'il y a
des paramètres optionnels (cf § VI)

Exemple 1 : Définition et exemples d'utilisation de f : x ↦
4
cos(2 )
( )
ln(2 )
x
e x
f x
x
=+
Script:
import math as ma
def f(x):
return(ma.exp(x)*ma.cos(2*x)/ma.log(2+x**4))
print('f(0)=',f(0))
t=2.3
y=1+f(t)**2
z=f(t+2/y)
print('y=',y,'z=',z)
Affichage dans la console :
f(0)= 1.4426950408889634
y= 1.1082042869667517 z= -3.7306882230249068
Remarques :
• L'instruction return provoque la sortie de la fonction ; si on place des instructions après l'instruction
return , elles sont ignorées (code mort)
Ex2
def f(x):
return –x
print('***')
print(f(1))
Résultat :
-1
NB : si le corps de la fonction contient une boucle, une instruction return dans le corps de cette
boucle provoque la sortie de la fonction, donc aussi de cette boucle. Ceci peut être utile.
• Une fonction ne retourne pas toujours le résultat d'un calcul; elle peut ne pas comporter
d'instruction " return ". (Dans ce cas elle renvoie tout de même "None")
Ex3a
def f(x):
y=x+1
print('*',y)
f(2) #bon appel
a=f(0) #mauvais appel!
print('a=',a)
Résultat :
* 3
* 1
a= None
• Ne pas confondre return et print :
Ex 3b
def g(x):
y=x+1
return y
g(2) #mauvais: g(2) est calculé mais perdu
a=g(0)
print('a=',a)
Résultat :
a= 1
On peut théoriquement introduire un appel de print dans une fonction qui comporte une instruction
return mais ceci risque de provoquer des affichages difficiles à interpréter lors de l'exécution :
(Conseil : ne le faire que provisoirement, pour tester éventuellement le bon fonctionnement d'une
fonction juste après l'avoir écrite, puis supprimer les instructions d'affichage dans la version finale)

Ex 3c
def f(x):
y=x+1
print('*',y)
return y
f(2) #résultat calculé mais non stocké
a=f(0) #résultat stocké dans la variable a
print('a=',a)
b=f(4)+f(10)
print('b=',b)
print(f(15)+f(2))
Résultat :
* 3
* 1
a= 1
* 5
* 11
b= 16
* 16
* 3
19
• Une fonction peut ne pas avoir d'argument (ou paramètre); dans ce cas lors de l'appel on fait tout de
même suivre le nom de la fonction de parenthèses :
Ex 4
def ligne():
print('--*'*4)
ligne()
Résultat :
--*--*--*--*