Les fonctions

Les fonctions sont des sous-programme que l’on peut exécuter. Elles sont en particulier utilisées pour effectuer des tâches répétitives.

Utiliser les fonctions

Il existe un grand nombre de fonctions déjà définies en Python. Certaines sont des fonctions natives, disponibles directement en Python (par exemple la fonction print). D’autres sont dans une librairie, par exemples, les fonctions mathématiques sont dans la librairie math.

Pour exécuter une fonction (on utilise aussi le mot appeler - call en anglais), il faut faire suivre le nom de la fonction par des parenthèses avec à l’intérieur les arguments séparés par des virgules.

Une fonction peut avoir zero argument, un ou plusieurs. Le nombre d’arguments n’est pas forcement fixé à l’avance.

list() # Fonction sans arguments

from math import cos # on importe la fonction cosinus
cos(1) # Cette fonction possède un seul argument

print('Bonjour', 'Hello') # La fonction print peut avoir autant d'argument qu'on le souhaite

Lorsqu’une fonction possède plusieurs arguments, il est important de respecter l’ordre. Lorsque l’on ne connait pas cet ordre, il faut regarder la documentation, ce qui peut se faire avec la commande nom_de_la_fonction? ou help(nom_de_la_fonction).

Regardons par exemple la fonction date du module datetime. Cette fonction permet de manipuler des dates avec Python.

from datetime import date
#date?

La documentation nous donne ;

date(year, month, day)

Cette fonction nécéssite donc 3 arguments (l’année, le mois et le jour).

On peut l’utiliser de la façon suivante :

bataille_marignan = date(1515, 9, 13)
print(bataille_marignan)

Pour lever l’ambiguité lorsqu’il y a plusieurs arguments, il est possible de nommer explicitement ceux-ci

bataille_marignan = date(year=1515, month=9, day=13)

Lorsque les arguments sont nommés, l’ordre n’a plus d’importance.

assert date(year=1515, month=9, day=13)==date(day=13, month=9, year=1515)

Attention, Python ne peut pas deviner ne nom de l’argument à partir du nom de la variable. Ceci ne fonctionnera pas :

year=1515
month=9
day=13

date(day, month, year)

Lorsqu’une fonction contient beaucoup d’arguments, il peut être utile de regrouper les variables dans une seule variable. Il peut s’agir soit d’une liste ou d’un n-uplet (tuple) auquel cas l’ordre sera important, soit d’un dictionnaire, auquel cas, les clés doivent correspondre aux noms des variables. Pour une liste on précéde l’objet d’une * pour un dictionnaire de **.

date_tpl = (1515, 9, 13)
date_dct = {"year":1515, 'month':9, "day":13}

print(date(*date_tpl))
print(date(**date_dct))

Création d’une fonction

Principe général

Le mot clé def est utilisé pour créer une fonction. Il doit être suivit du nom de la fonction, des arguments placés entre parenthèse. Comme toute instruction qui sera suivi d’un bloc d’instruction, il faut terminer la ligne par un :. Le bloc d’instruction sera alors indenté.

# Fonction sans argument
def affiche_bonjour():
    print('Bonjour tout le monde')
    print('Hello World!')
    
affiche_bonjour()

Pour renvoyer une valeur, il faut utiliser l’instruction return.

from math import pi

def surface_d_un_disque(r):
    return pi*r**2

surface_d_un_disque(3)

Python quitte la fonction imédiatement après le return. Il peut y avoir plusieurs return dans une fonction. Python quitte la fonction après le premier return executé. Si il arrive à la fin de la fonction, alors il y a un return implicite. La valeur renvoyée est None.

Dans cet exemple, le print('B') ne sera jamais executé

def f():
    print('A')
    return
    print('B')
    
f()

def f(x):
    a = x**2
    # Il n'y a pas de return. Cette fonction ne sert donc à rien
    
print(f(1))

from math import sin, cos, tan

def f(x, case):
    if case=='A':
        return sin(x)
    if case=='B':
        return cos(x)
    if case=='C':
        return tan(x)

Une fonction peut renvoyer plusieurs valeurs. Pour cela on les sépare par des virgules. On peut récupérer les valeurs en séparant les variables par des virgules à gauche du signe =.

from math import cos, sin

def coordonnees(r, theta):
    return r*cos(theta), r*sin(theta)

x, y = coordonnees(1, 3)

Chaîne de documentation

Si la première ligne du bloc d’instruction d’une fonction est une chaîne de caractère litérale, alors cette chaîne sera la chaîne de documentation de la fonction. Cette chaîne correspond à la description de la fonction.

def surface_d_un_disque(r):
    "Calcule la surface d'un disque de rayon r"
    return pi*r**2

help(surface_d_un_disque)

Lorsque la chaîne de caractère prend plusieurs lignes (ce qui est en générale le cas…), alors il est préférable d’utiliser une chaîne avec triple guillemets.

def surface_d_un_disque(r):
    """Calcule la surface d'un disque
    
    Utilise simplement la formule $\pi r^2$
    
    Arguments :
        r (float) : rayon du disque
        
    Renvoie : 
        float : le surface du disque
    """
    return pi*r**2

help(surface_d_un_disque)

La chaîne de documentation est différente des commentaires (#): ces derniers ne sont pas disponibles aux utilsateurs, mais seulement à celui qui lira et voudra comprendre le code.

Variables locales

Une variable est locale lorsqu’elle n’est définie que à l’intérieur d’une fonction. Une variable est globale lorsque sa definition est à l’extérieure de la fonction. Il n’y a pas d’interaction entre une variable locale et une variable portant le même nom à l’extérieur de la fonction

Toutes les variables qui sont affectées dans la fonction (i.e. pour lesquels on a une ligne variable=...) ainsi que les arguments de la fonction sont des variables locales.

x = 1
def f(): # x est une variable globale
    print(x)
    
f()

x = 1
def f(): # x est une variable locale
    x = 3
    print(x)
    
print(x)
f()
print(x)

La valeur prise par une variable globale est la valeur au moment de l’exection de la fonction et non au moment de la définition de la fonction

#### NE FONCTIONNE PAS ###
coef = 2
def double(x):
    return coef*x

coef = 3
def triple(x):
    return coef*x

print(double(3))
print(triple(3))

9
9

Arguments optionels

Il est possible de donner une valeur par défaut à un argument. Celui-ci sera alors optionnel. Cela se fait avec la syntaxe def f(.., arg=default_value). Les arguments optionels doivent être définis à la fin de la liste des arguments.

def f(a, b=1):
    print(a*b**2)

f(1)
f(1, 5)
f(b=4, a=1)

Fonction avec un nombre arbitraire d’arguments

Il est possible de définir une fonction avec un nombre arbitraire d’arguments en utilisant la syntaxe *arg. Dans ce cas, la variable arg sera un n-uplet (tuple) qui contiendra tous les arguments suplémentaires.

def mafonction(a, b, *args):
    print('a = ', a)
    print('b = ', b)
    print('args =', args)
    
mafonction(1, 2, 3, 4)

Il est aussi possible de définir une fonction avec un nombre arbitraire d’arguments nommés. Dans ce cas, il faut utiliser la syntaxe **kwd. La variable kwd est alors un dictionnaire dont les clés sont les noms des variables.

def mafonction(a, b, **kwd):
    print('a = ', a)
    print('b = ', b)
    print('kwd = ', kwd)
    
# mafonction(1, 2, 3, 4) # erreur
mafonction(1, 2, alpha=1, beta=3)