1. Généralités

1.1. Vocabulaire

Ne pas confondre avec les méthodes de la programmation orientée objet.

Le mot fonction est parfois utilisé de façon vague. Pour bien faire la distinction avec les procédure, on dira fonction pure.

1.2. Similarité avec les fonctions pures

Mêmes buts que ceux décrits pour les fonctions pures :
repérer des motifs et ne pas les répéter bêtement à la main.

1.3. Différences avec les fonctions pures

1.3.1. Intéractions avec l’extérieur

Les procédures peuvent avoir une influence sur l’état du programme ou sur l’état du monde physique :

• état des variables du programme (globales ou déclarées en sortie),
• état physique avec l’écran, une imprimante ou tout périphérique…

Ici on entend par extérieur ce qui est en dehors de la procédure.

1.3.2. Valeur de retour

Les procédures peuvent ne pas avoir de valeur de retour.

Si la procédure a une valeur de retour, on peut utiliser l’appel comme on le fait avec une fonction pure (affectation ou expression).

Si la procédure n’a pas de valeur de retour, l’utilisation de l’appel n’a aucun sens, ni pour un affichage, ni pour une affectation, ni dans une expression.

Une procédure sans valeur de retour donnera son résultat en modifiant la valeur d’une variable (voir plus loin).

2. Syntaxe en pseudo-code

2.1. Une fonction se fait passer pour une procédure

Procédure ma_proc(E param1: type1; E param2: type2)
    ...
    Retourner ...
Fin procédure

Dans les premiers pointillés, on ne veut pas d’entrée/sortie, pas d’intéraction avec l’extérieur.

2.2. Deux paramètres, un d’entrée, un de sortie

Procédure ma_proc(E param1: type1; S param2: type2)
    ...
    param2 <- ...
Fin procédure

Par de Retourner dans cette procédure. Exemple :

Algo doubler_1
Variables: m, n entiers
Procédure double(E m: entier; S n: entier)
    n <- 2*m
Fin procédure
Début algorithme
    Afficher "Entrer un nombre: "
    Demander m
    double(m, n)  # pas d’affectation car pas de valeur de retour
    Afficher n
Fin algorithme

Remarque : On ne peut pas écrire

• Afficher double(m, n)
• double(m, n) + 2

car l’appel à double ne porte pas le résultat. Le résultat est dans la nouvelle valeur de n.

2.3. Un paramètre, qui sert d’entrée et de sortie

Procédure ma_proc(E/S param1: type1)
    ...
    param1 <- ...
Fin procédure

Exemple :

Algo doubler_2
Variable: n entier
Procédure double(E/S n: entier)
    n <- 2*n
Fin procédure
Début algorithme
    Afficher "Entrer un nombre: "
    Demander n
    double(n)
    Afficher n
Fin algorithme

3. Syntaxe en Python

def ma_proc(param1, param2, param3):
    global var1, var2
    ...
    ...  # return possible ici (ou avant)

En Python, à l’intérieur d’une fonction/procédure, on peut accéder :

• en lecture aux arguments passés en paramètre,
• en lecture aux variables qui étaient initialisées avant le def (closure, hors programme),
• en écriture aux variables déclarées avec le mot clef global (pour plus de détails, consulter la documentation de global et de nonlocal).

3.1. Exemple d’utilisation

3.1.1. Fonctionne

def double():
    global n
    n = 2*n

print("Entrer un nombre: ")
n = int(input())
double(n)
print(n)

3.1.2. Effet shadowing

def double(n):
    n = 2*n      # ce n fait de l’ombre au n global

print("Entrer un nombre: ")
n = int(input())
double(n)        # le n global ne pourra pas être modifié ainsi
print(n)         # affiche le nombre entré et non son double

3.2. Python retourne toujours

À la fin des fonctions/procédures en Python, il est équivalent de taper :

• return None,
• return
• pas de return du tout.