21 – Python : les fonctions

Navigation :

• Introduction
• Déclarer une fonction
• Appeler une fonction
• Déclaration de fonction avec valeur retour
• Paramètres de fonction
• Paramètres par défaut
• Fonctions multi-paramètres
• Espace global
• Variable globale au sein d’une fonction

Introduction

Les fonctions en Python sont similaire aux fonctions en mathématique. Il s’agit d’un « bout de code » réutilisable dédié à une tâche en particulier.

Il y a deux grandes familles de fonctions :

• Les fonctions avec retour de valeur, comme la fonction type()
• Les fonctions sans retour, comme la fonction print()

Déclarer une fonction

Pour déclarer une fonction, par ordre chronologique il faut :

• commencer son bloc par « def » comme « define » pour indiquer à Python que l’on commence à créer une fonction.
• spécifier le nom de la fonction et lui ajouter « () »
• fermer le bloc par « : »
• indenter la bloc d’instruction
• indiquer à Python le code que devra exécuter la fonction.

Concrétement :

def myFunction():
    print("Something")

Appeler une fonction

On appel tout simplement son nom suivie de parenthèses :

def myFunction():
    print("Something")

myFunction()

>>> Something

Déclaration de fonction avec valeur retour

Pour les fonctions avec retour de valeur, il convient de spécifier lors de la déclaration ce que l’on veut que la fonction retourne avec le mot « return »

def myFunction():
    return 10

Ce qui donne :

def myFunction():
    return 10
print(myFunction())

>>> 10

L’instruction return ARRÊTE la déclaration de la fonction, tout ce qui se trouve en dessous ne sera jamais exécuté.

Néanmoions attention, un return arrête la fonction dans le bloc en cours, il est alors possible d’avoir plusieurs return dans une déclaration de fonction si ils sont dans des blocs différents :

def myFunction(a):
    if a == 1:
        return True
    else:
        return False
print(myFunction(1))

>>> False

Paramètres de fonction

Les paramètres sont ce qui va se trouver entre parenthèses lors de la déclaration des fonctions.

Plus tard, lors de l’appel de notre fonction, ces paramètres seront remplacés par des arguments.

def my_Function(a):
    print(a)

Ou encore :

def my_Function(a):
    b = a + 2
    return b

result = my_Function(2)
print(result)

>>> 4

Paramètres par défaut

Si on envoi des arguments vide à une fonction, Python renverra une erreur et le script cessera de fonctionner.

Pour éviter cela il est possible de définir dans les paramètres, une valeur par défaut :

def my_Function(a="Valeur pas défaut"):
    print(a)

Ou plus concrétement :

def my_Function(a=6):
    b = a + 2
    return b

result = my_Function()
print(result)

>>> 8

Fonctions multi-paramètres

Il est bien évidemment possible de créer des fonctions capable de traiter plusieurs paramètres. Dans la définition des paramètres, il suffit alors de séparer ces paramètres par des virgules :

def my_Function(a, b):
    b = a + b
    return b

result = my_Function(10, 2)
print(result)

>>> 12

Par defaut, Python va assigner les arguments dans l’ordre dans laquelle ils sont entrés. Pour reprendre l’exemple du dessus, 10 est automatiquement assigné à a et 2 est automatiquement assigné à b.

Il est toutefois possible de spécifier un ordre différent lors du renseignement de ces arguments :

def my_Function(a, b):
    b = a - b
    return b

result = my_Function(b=10, a=2)
print(result)

>>> -8

En cas de paramètres multiple, il est possible de ne pas spécifier le même nombre d’arguments. Python assigne donc toujours par défaut les premières arguments aux premier paramètre et complète par les paramètres par défaut :

def my_Function(a=1, b=2, c=6):
    return a + b + c

result = my_Function(3,5)
print(result)

>>> 14

Espace global

Chaque fonction crée ce que l’on appel sont espace global dans lequel tout ce qui s’y passe ne concerne que la déclaration de la fonction.

Dans cette exemple, les deux variable b n’ont rien a voir entre elles :

def my_Function(a):
    b = 5
    return a + b

b = 200
result = my_Function(5)
print(result)
print(b)

>>> 10
>>> 200

Exception fait à une variable déclaré au dessus de la définition de la fonction qui passe à travers la définition de la fonction :

b = 200
def my_Function(a):
    return a + b

result = my_Function(5)
print(result)
print(b)

>>> 205
>>> 200

Sauf si on redéfini b à l’intérieur de la fonction :

b = 200
def my_Function(a):
    b = 5
    return a + b
result = my_Function(5)
print(result)
print(b)

>>> 10
>>> 200

Variable globale au sein d’une fonction

Ce qui suit est plutôt à titre d’info puisque pour des raisons de simplicité, on évitera de recourir à cette techniques.

Au sein d’une fonction, si l’on modifie une variable reçu depuis l’espace globale nous obtenons une erreur de la part de Python :

a = 10
def my_Function():
    a += 1
    return a
result = my_Function()
print(result)
print(a)

>>> Traceback (most recent call last):
>>>  File "tests.py", line 5, in <module>
>>>     result = my_Function()
>>>   File "tests.py", line 3, in my_Function
>>>     a += 1
>>> UnboundLocalError: local variable 'a' referenced before assignment

Si l’on souhaite faire ce genre d’opération, il faut spécifier explicitement à la fonction que l’on souhaite utiliser une variable en tant que variable globale :

a = 10
def my_Function():
    global a
    a += 1
    return a
result = my_Function()
print(result)
print(a)

>>> 11
>>> 11

Noter que la variable est bien modifier dans l’espace globale à la fin du script.