Fonctions
Il est possible avec Python de définir une fonction à la manière d’une fonction mathématique ; la syntaxe est alors la suivante :
Définition mathématique | Définition Python | |
---|---|---|
\(f:x \rightarrow x^2\) | ⇔ |
def f(x): return x**2 |
Mais on peut définir des fonctions beaucoup plus complexes …
Déclaration d’une fonction
Une fonction doit d’abord être déclarée (ou définie).
Voici la forme générale de déclaration d’une fonction :
def ma_fonction([paramètre(s)]): ... instructions ... [return resultat] |
ici les crochets [ ] signalent des paramètres ou lignes facultatifs (il ne faut pas les saisir !) |
La déclaration d’une fonction commence par le mot clé (ou déclaration – statement) def
puis vient le nom de la fonction ma_fonction
, puis placés entre parenthèses les éventuels paramètres, le tout ponctué de :
(deux points).
Le contenu de la fonction (séquence d’instructions) se situe intégralement dessous la ligne de déclaration et doit impérativement être indenté d’un cran (une tabulation).
Remarque : dans la plupart des éditeurs dédiés au langage Python, un appui sur la touche « Entrée » après le
:
crée automatiquement une indentation.
Si la fonction doit retourner un résultat, cela se fait par l’instruction return
, suivie du résultat. Dans le cas contraire, on parle de procédure.
Une propriété remarquable de l’instruction return
est qu’elle interrompt systématiquement l’exécution de la fonction : inutile donc de placer des instructions après un return
car ces instructions ne seront jamais lues par l’interpréteur. On parle parfois de code mort pour désigner les lignes qui suivent (à l’intérieur de la définition d’une fonction) l’instruction return
.
def power(a,n): return a**n print("C’est inutile d’écrire ici") # c’est du code mort !
Appel d’une fonction
Une fois déclarée, on peut appeler la fonction :
ma_fonction([arguments]) # s'il s'agit d'une procédure
ou bien
resultat = ma_fonction([arguments]) # s'il s'agit d'une fonction
Dans ce cas, la variable resultat
prend la valeur retournée par ma_fonction()
.
L’objet fonction
Comme tous les éléments dans Python, une fonction est un objet :
def ma_fonction(arg): y = arg*6 + 5 return y
>>> ma_fonction <function ma_fonction at 0x036F8EB0>
On trouve entre les crochets :
<nom du type nom de l’objet at adresse de l’objet>
On peut aussi tester :
>>> type(ma_fonction) <type 'function'>
Et puisque une fonction est un objet, on peut l’utiliser comme une variable, lui donner plusieurs noms :
>>> meme_fonction = ma_fonction >>> meme_fonction <function meme_fonction at 0x036F8EB0>
ma_fonction
et meme_fonction
sont deux noms différents pour une seule et même fonction (même emplacement dans la mémoire).
Les arguments
On peut passer des arguments à une fonction sous deux formes :
- sans mot clef (ou positionnels) (non-keyword arguments ou positional arguments) : ils sont ordonnés, comme dans une liste
- avec mot clef (keyword arg) : ils possèdent une clef (un nom), comme dans un dictionnaire, et ne sont pas ordonnés
def ma_fonction(arg1, arg2, karg1 = "e", karg2 = 5): print(arg1, arg2, karg1, karg2)
Dans cet exemple, arg1
et arg2
sont des arguments positionnels, sans mot clef : ils sont obligatoires !
Alors que karg1
et karg2
sont des arguments avec mot clef : ils sont facultatifs, possèdent une valeur par défaut, et on peut les faire passer dans le désordre (mais obligatoirement après tous les arguments positionnels !)
Tous ces appels à ma_fonction()
sont valides :
>>> ma_fonction(1, "oui", karg1 = "ISN", karg2 = 0) 1 'oui' 'ISN' 0
>>> ma_fonction(1, "oui", "ISN", 0) 1 'oui' 'ISN' 0
>>> ma_fonction(1, "oui", karg2 = 0, karg1 = "ISN") 1 'oui' 'ISN' 0
>>> ma_fonction(1, "oui", karg1 = "ISN") 1 'oui' 'ISN' 5
>>> ma_fonction(1, "oui") 1 'oui' 'e' 5
En revanche ces appels provoquent une erreur :
>>> ma_fonction(1, karg1 = "ISN", "oui", karg2 = 0) SyntaxError: non-keyword arg after keyword arg
>>> ma_fonction(1, karg1 = "ISN", karg2 = 0) Traceback (most recent call last): File "<pyshell#20>", line 1, in <module> ma_fonction(1, karg1 = "ISN", karg2 = 0) TypeError: ma_fonction() missing 1 required positional argument: 'arg2' # avant python 3.4 : TypeError: ma_fonction() takes at least 2 arguments (3 given)
>>> ma_fonction(1, "oui", karg1 = "ISN", karg3 = 0) Traceback (most recent call last): File "<pyshell#21>", line 1, in <module> ma_fonction(1, "oui", karg1 = "ISN", karg3 = 0) TypeError: ma_fonction() got an unexpected keyword argument 'karg3'
Variable locale, variable globale
x = 0 def f(y): x = 1 return y f(2) print(x)
Toute variable définie à l’intérieur du corps d’une fonction, n’est accessible qu’à la fonction elle-même. On la qualifie de variable locale à la fonction.
Une variable définie à l’extérieur de toute fonction sera quant à elle appelée variable globale.
Si une variable locale porte le même nom qu’une variable globale, cette dernière sera ignorée pendant l’exécution de la fonction.
Une variable globale (si aucune autre variable locale ne porte le même nom) peut être lue à l’intérieur d’une fonction.
Mais pour qu’elle puisse y être modifiée, il faut utiliser la déclaration global
en début de définition de la fonction.
x = 0 def f(y): global x x = 1 return y f(2) print(x)
À la fin de l’exécution de la fonction, les variables locales sont détruites (mécanisme de ramasse-miettes).
def f(y): var_locale = 1 return y f(2) print(var_locale)
Aide d’une fonction
On a vu dans l’introduction à python qu’une fonction pouvait avoir une aide, indiquant ce que fait et comment utiliser une fonction.
>>> import random >>> help(random.random) Help on built-in function random: random(...) random() -> x in the interval [0, 1).
Les fonctions définies par l’utilisateur peuvent aussi en avoir une :
def ma_fonction(x, y): """ Fonction qui calcule x**y """ return x**y help(ma_fonction)
Help on function ma_fonction in module __main__: ma_fonction(x, y) Fonction qui calcule x**y