Les fonctions

a) Notion de fonction

Les fonctions sont des blocs de code qui permettent de diviser un programme complexe en plusieurs sous-programmes plus simples. Cela facilite la lecture, la compréhension et la maintenance du code.

Pourquoi utiliser des fonctions ?

Réutilisabilité : On peut écrire un morceau de code une fois dans une fonction, puis l’utiliser plusieurs fois sans le recopier.

Organisation : Un programme bien structuré utilise des fonctions pour séparer les différentes tâches.

Clarté : Chaque fonction a un rôle précis, ce qui rend le code plus clair.

Fonction en mathématiques vs informatique

En mathématiques, une fonction associe à une valeur d’entrée une valeur de sortie. Par exemple, la fonction $y=3x+2$ associe à chaque valeur de xx une valeur de $y$ .

Si $x=4$ , alors $y=3×4+2=14$ .

En informatique, la fonction suit la même idée : pour une ou plusieurs entrées (appelées paramètres), elle renvoie une sortie (appelée valeur de retour).

Syntaxe Python pour définir une fonction

def nom_de_la_fonction(parametre1, parametre2, ...):
    instruction_1
    instruction_2
    ...
    return valeur

Le mot-clé def sert à définir une fonction.

Le nom de la fonction doit être clair et explicite.

Les paramètres sont optionnels : on peut définir des fonctions sans paramètres.

Le corps de la fonction est indenté (décalé à droite) par rapport à la ligne def.

Le mot-clé return permet de renvoyer une valeur à la fin de la fonction.

Exemple simple

On traduit la fonction mathématique $y=3x+2$ en Python :

def ma_fonction(x):
    y = 3 * x + 2
    return y

Pour utiliser la fonction, on écrit :

resultat = ma_fonction(4)
print(resultat)  # Affiche 14

Ici, on passe la valeur 4 en paramètre.

La fonction calcule $3×4+2=14$ .

La valeur 14 est renvoyée par return et stockée dans resultat.

Passage de plusieurs paramètres

On peut définir une fonction avec plusieurs paramètres :

def calcul(x, b):
    y = 2 * x + b
    return y

On appelle la fonction en précisant l’ordre des paramètres :

valeur = calcul(4, 3)
print(valeur)  # Affiche 11 (2*4 + 3)

Attention : l’ordre des paramètres est important, x prendra la valeur 4, b la valeur 3.

Les paramètres peuvent être de différents types

Les paramètres ne sont pas limités aux nombres. Ils peuvent être :

Des chaînes de caractères

Des booléens

Des listes, des dictionnaires, etc.

Exemple avec des chaînes de caractères :

def dit_bonjour(nom, age):
    phrase = f"Bonjour {nom}, vous avez {age} ans."
    return phrase

message = dit_bonjour("Alice", 25)
print(message)  # Affiche : Bonjour Alice, vous avez 25 ans.

Ici, on utilise la f-string (littéral de chaîne formatée) pour insérer les variables dans la chaîne.

b) Les fonctions natives de Python

Python possède de nombreuses fonctions intégrées, appelées fonctions natives, que l’on peut utiliser directement.

Quelques fonctions natives importantes

print() : Affiche du texte ou des valeurs à l’écran.

print("Hello world")

len() : Renvoie la longueur (nombre d’éléments) d’une chaîne de caractères, d’une liste, etc.

print(len("azerty"))  # Affiche 6

type() : Donne le type d’une variable.

print(type(3))        # Affiche <class 'int'>
print(type("texte"))  # Affiche <class 'str'>

str() : Convertit une valeur en chaîne de caractères.

print(str(4))         # Affiche '4'

Il en existe beaucoup d’autres, couvrant divers besoins (conversion, mathématiques simples, manipulation de données, etc.).

c) Les modules en Python

Python permet d’utiliser des fonctions supplémentaires via des modules. Un module est un fichier contenant des fonctions, classes, constantes, etc., que l’on peut importer dans son programme.

Exemple : module math

Le module math contient des fonctions mathématiques classiques :

math.sqrt() : racine carrée

math.sin(), math.cos() : sinus, cosinus

math.pow() : puissance

Pour utiliser un module, on importe le module au début du programme :

import math

Puis on appelle les fonctions avec la syntaxe : nom_du_module.nom_de_la_fonction(paramètre)

resultat = math.sqrt(16)
print(resultat)  # Affiche 4.0

Exemple complet avec module math

import math

a = 5
b = 16
c = 3.14

puissance = math.pow(a, 3)    # 5^3 = 125
racine = math.sqrt(b)         # racine carrée de 16 = 4
sinus = math.sin(c)           # sinus de 3.14 ≈ 0.00159

print(puissance)
print(racine)
print(sinus)

d) Le mot-clé `return`

Le mot-clé return sert à indiquer la valeur que la fonction doit renvoyer à son appelant.

Sans return, une fonction ne renvoie rien explicitement.

Python renvoie implicitement None si aucun return n’est présent.

Exemple sans return

def ma_fonction(i):
    d = 5
    z = i + d

resultat = ma_fonction(3)
print(resultat)  # Affiche None

7) Variables locales et variables globales

a) Variables et fonctions

Variables locales

Une variable définie à l’intérieur d’une fonction est dite locale : elle existe uniquement pendant l’exécution de la fonction.

Exemple :

def ma_fonction():
    i = 5  # variable locale

ma_fonction()
print(i)  # Erreur : i n'est pas défini ici

Ici, i existe seulement dans ma_fonction et n’est pas accessible en dehors, donc on obtient une erreur.

Variables globales

Une variable définie en dehors de toute fonction est dite globale : elle est accessible dans tout le programme, sauf si elle est cachée par une variable locale du même nom.

Exemple :

i = 3  # variable globale

def ma_fonction():
    print(i)  # affiche la variable globale i

ma_fonction()  # Affiche 3
print(i)       # Affiche 3

Variables locales cachant une variable globale

Si une variable locale porte le même nom qu’une variable globale, la locale cache la globale à l’intérieur de la fonction.

i = 3  # globale

def ma_fonction():
    i = 5  # locale, différente de la globale
    print(i)  # Affiche 5

ma_fonction()
print(i)  # Affiche 3 (la globale n'a pas changé)

Modifier une variable globale dans une fonction : le mot-clé `global`

Par défaut, on ne peut pas modifier une variable globale directement dans une fonction. Si on essaye, on obtient une erreur.

i = 3

def ma_fonction():
    i = i + 1  # erreur : i local utilisée avant d'être définie

ma_fonction()
print(i)

Pour modifier une variable globale, on doit utiliser global :

i = 3

def ma_fonction():
    global i
    i = i + 1  # modifie la variable globale

ma_fonction()
print(i)  # Affiche 4

b) Les effets de bord

Qu’est-ce qu’un effet de bord ?

Un effet de bord survient lorsqu’une fonction modifie une variable globale, c’est-à-dire qu’elle modifie l’état du programme en dehors d’elle-même.

Cela peut poser problème car :

Cela rend le programme moins prévisible : la valeur d’une variable peut changer à tout moment.

Cela complique la lecture et la compréhension du code.

Cela peut entraîner des bugs difficiles à détecter.

Pourquoi éviter les effets de bord ?

Dans des programmes simples, ce n’est pas un souci. Mais dans des programmes complexes, il vaut mieux que les fonctions :

Prennent des paramètres en entrée,

Renvoient un résultat,

Sans modifier directement l’état global.

C’est le principe de la programmation fonctionnelle, qui limite les effets de bord pour rendre le code plus sûr et plus facile à tester.