Fonctions en

À propos de Fonctions

Une function est un bloc de code organisé et réutilisable qui sert à accomplir une tâche précise. Les Functions offrent une meilleure modularité à l'application et un haut degré de réutilisation du code. Python, comme d'autres langages de programmation, dispose de fonctions intégrées (print, map, etc.) directement accessibles. Tu peux aussi définir tes propres fonctions. On les appelle des user-defined functions. Les fonctions peuvent accomplir des choses aussi simples qu'afficher un message dans la console, ou être bien plus complexes.

Pour exécuter le code contenu dans une fonction, il faut appeler cette fonction : on écrit son nom, suivi de parenthèses [()]. Les données, que l'on appelle arguments, peuvent être transmises à la fonction en les plaçant entre ces parenthèses. Une définition de fonction peut comporter zéro ou plusieurs parameters. Les paramètres définissent le ou les arguments que la fonction accepte. Un paramètre définit quel type d'argument doit être transmis. L'argument, lui, est la valeur réellement transmise au moment de l'appel. Les fonctions peuvent effectuer différentes tâches selon les arguments transmis aux paramètres.

Une fonction peut aussi renvoyer une valeur à l'aide du mot-clé return. La valeur renvoyée par la fonction s'appelle la return value. La valeur de retour est renvoyée à l'appelant de la fonction.

Création

En Python, les fonctions se créent à l'aide du mot-clé def. La définition de la fonction commence par le nom de la fonction, suivi de parenthèses [()]. À l'intérieur des parenthèses, on indique les paramètres, séparés par des virgules. Après la parenthèse fermante, le deux-points (:) sépare la signature de la fonction de son corps.

Le corps de la fonction est un bloc de code exécuté lorsque la fonction est appelée. Ce corps est indenté. L'indentation est importante, car Python s'appuie sur elle pour savoir où se termine ce bloc de code. On peut renvoyer une valeur depuis la fonction à l'aide du mot-clé return, que l'appelant de la fonction pourra ensuite utiliser.

def function_name(parameter1, parameter2, ...):
    # function body
    return parameter1 + parameter2

On peut aussi définir une fonction sans aucun paramètre ni valeur de retour.

def function_name():
    # function body
    pass

À noter qu'une fonction a tout de même besoin d'un corps, même si celui-ci ne fait rien. Sinon, lancer le programme produira une erreur d'indentation :

>>> def my_bodyless_func():
...      

File ~/temp.py:1
    
    ^
IndentationError: expected an indented block

Appeler une fonction

Pour appeler une fonction, on utilise son nom suivi de parenthèses [()]. Les paramètres transmis à la fonction se placent entre ces parenthèses, séparés par des virgules.

Prenons la fonction suivante :

def greet():
    print("Hello")

On peut appeler la fonction ci-dessus avec la syntaxe suivante :

>>> greet()
Hello

Les paramètres et leurs arguments

Les arguments sont les valeurs transmises à la fonction au moment de l'appel. Ils peuvent être de n'importe quel type de données, y compris d'autres fonctions ou des classes.

Définissons une fonction add qui additionne deux nombres :

def add(first, second):
    print(first + second)

Les paramètres first et second définissent quels arguments la fonction add acceptera. (À noter que les mots parameter et argument sont souvent employés l'un pour l'autre, un peu abusivement.) Lorsque la fonction est appelée, les arguments lui sont transmis. Il faut fournir un argument pour chacun des deux paramètres, sinon une TypeError sera levée.

>>> add(2, 3)
5

# Function can be called multiple times, with different parameters
>>> add(4, 3)
7
>>> add(5, 6)
11

# Passing an incorrect number of parameters will raise a `TypeError`
>>> add(2)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: add() missing 1 required positional argument: 'second'

>>> add(2, 3, 4)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: add() takes 2 positional arguments but 3 were given

La valeur de retour

La valeur de retour est la valeur renvoyée à l'appelant de la fonction. Une return value peut être de n'importe quel type de données, y compris d'autres fonctions ou des classes. L'appelant de la fonction peut s'en servir pour effectuer d'autres opérations. Si une fonction ne définit pas explicitement de return value, l'interprète Python renvoie la valeur None.

Définissons une fonction add :

def add(first, second):
    return first + second

On peut stocker la valeur de retour dans une variable, puis l'afficher :

>>> result = add(2, 3)
>>> print(result)
5
# Type of result is `int`
>>> type(result)
<class 'int'>

# We can also perform operations on the return value
>>> result * 2
10

# A function without an explicit return value will return `None`
>>> def log(message):
    print(message)

# Hello is printed because of print(message), but return value is `None`
>>> return_value = log("Hello")
Hello
>>> return_value
None

L'emploi de return quitte immédiatement la fonction et renvoie la valeur à l'appelant.

>>> def show(first, second):
    print(first)
    return first
    print(second)

# second never gets printed, because the function exits after the return statement
>>> show(1, 2)
1

Modularité

Les programmes complexes peuvent être découpés en parties plus petites. Différentes fonctions peuvent servir à accomplir des tâches précises différentes.

Imaginons qu'un programme doive effectuer les tâches suivantes :

• Calculer l'aire d'un cercle
• Calculer l'aire d'un rectangle
• Calculer l'aire d'un triangle

On peut découper le programme en parties plus petites.

def circle_area(radius):
    return 3.14 * radius * radius

def rectangle_area(length, breadth):
    return length * breadth

def triangle_area(base, height):
    return 0.5 * base * height

On peut maintenant appeler les fonctions dans l'ordre que l'on veut.

>>> circle_area(2)
12.56
>>> triangle_area(2, 3)
3.0
>>> rectangle_area(2, 3)
6
>>> rectangle_area(1, 2) + circle_area(2) + triangle_area(1, 2)
15.56

La portée des variables

Si une variable (ou un nom) est définie à l'intérieur d'une fonction, elle n'est accessible qu'à l'intérieur de la portée de cette fonction (ou de son espace de noms local), même s'il existe une variable portant le même nom en dehors de la portée de la fonction.

Les variables définies en dehors d'une fonction, au niveau du module, appartiennent à l'espace de noms global. Les variables définies en dehors d'une fonction mais à l'intérieur d'une fonction englobante ou d'une classe appartiennent à l'espace de noms non local.

Python utilise la règle LEGB (Local, Enclosing, Global, Built-in) pour résoudre les noms de variables pendant l'exécution d'un programme :

1. Recherche dans l'espace de noms local (ou de la fonction).
2. Recherche dans l'espace de noms englobant (ou non local) si le nom n'est pas trouvé dans le local.
3. Recherche dans l'espace de noms global (niveau du module) si le nom n'est pas trouvé dans le non local ou l'englobant.
4. Recherche dans l'espace de noms built-in (du programme ou de Python tout entier) si le nom n'est pas trouvé dans le global.

Si le nom reste introuvable, Python lève une NameError exception.

# Global namespace.
general_favorite = "apples"


def alices_favorite():
   # Local namespace.  
   favorite = "cherries"
   
   # This works because Python will eventually find general_favorite in the global namespace.
   # Python will find 'print' in the built-in namespace.
   print(f'Alice has always liked {favorite}, but most people like {general_favorite}.')

   
def our_favorite_fruits():
    # Enclosing or nonlocal namespace.
    yours = "peaches"
    
    def my_favorite():
        # Local namespace.
        mine = "pears"
        
        # This works because Python will eventually find 'yours' in the enclosing/nonlocal namespace.
        print(f'My favorite is {mine}, but you like {yours} instead.')
        
        # This works because Python will eventually find 'general_favorite' in the global namespace.
        print(f'Everyone seems to like {general_favorite}')
    
    # This function is in the local namespace of the 'our_favorite_fruits' function.  
    my_favorite()

    
# This will raise NameError: name 'favorite' is not defined, because the variable favorite is local to alices_favorite.
print(favorite)

Si l'on veut rendre un nom de variable accessible en dehors de la portée locale de la fonction (ou modifier une variable définie en dehors de cette portée), il faut utiliser le mot-clé global ou nonlocal.

Employer le mot-clé global indique à Python de commencer la recherche dans l'espace de noms global. Les affectations à la variable modifieront alors la variable globale, au lieu de créer une version locale. Lorsque global sert à déclarer une variable, celle-ci est ajoutée à l'espace de noms global. Par conséquent, global doit être employé avec prudence : ajouter ou modifier une variable globale peut avoir des répercussions sur tout le reste du code qui utilise sa valeur.

Le mot-clé nonlocal indique à Python de chercher ou de créer la variable dans l'espace de noms non local ou englobant. On l'utilise lorsqu'une fonction est imbriquée dans une autre fonction ou une classe et a besoin d'accéder aux variables et à la portée de la fonction extérieure.

Les fonctions comme objets de première classe

En Python, les fonctions peuvent être affectées à des variables et transmises comme arguments à d'autres fonctions. Elles peuvent servir de valeurs de retour. Une fonction peut aussi être placée dans une séquence (list, tuple, etc.) ou comme valeur dans un dict. Une fonction peut être utilisée partout où un autre objet peut l'être. C'est parce que les fonctions sont des objets de première classe. À ce titre, elles portent des attributs particuliers et peuvent même définir la lecture et l'écriture de leurs propres attributs personnalisés.

# print is a function

# A function can be assigned to a variable.
>>> function_as_variable = print
>>> function_as_variable("Hello")
Hello
>>> type(fake_print)
<class 'builtin_function_or_method'>

# Functions can be passed as an argument to another function.
>>> def check_print(func):
    func("Hello")
>>> check_print(print)
Hello

# Function can be used as an item in a sequence.
>>> my_list = [print, "Hello"]
>>> my_list[0]("Hello")
Hello

# Functions can be used as a value in a dictionary.
>>> my_dict = {"key": print}
>>> my_dict["key"]("Hello")
Hello

# Functions can be returned from a function.
>>> def return_func():
    return print
>>> return_func()("Hello")
Hello

Les fonctions peuvent aussi être imbriquées dans d'autres fonctions.

def outer():
    num = 10
    
    # This is a nested, or "inner" function.
    def inner():
        print(num)
    
    # Outer function calling inner function
    inner()

La fonction interne peut accéder à la variable num définie dans la fonction externe.

>>> outer()
10

Les attributs spéciaux

Les fonctions en Python possèdent des attributs spéciaux. En voici quelques-uns :

• __name__ : nom de la fonction
• __doc__ : chaîne de documentation de la fonction
• __module__ : module dans lequel la fonction est définie
• __globals__ : dictionnaire des variables globales de la fonction
• __code__ : objet code contenant les instructions de la fonction

>>> def add(first, second):
      return first + second

# Function name
>>> print.__name__
'print'
>>> len.__name__
'len'
>>> add.__name__
'add'

# Function documentation
>>> abs.__doc__
'Return the absolute value of the argument.'

# Module
>>> len.__module__
'builtins'
>>> add.__module__
'__main__'

La liste complète des attributs de fonction se trouve dans le modèle de données Python.