Fonctions en python
2025-2026
fonction: du maths vers python
une fonction est un calcul effectué sur des En Python, c'est exactement pareil !
entrées(paramètres) pour produire des
résultats. def f(x):
En mathématiques: f(x) = 2x + 3 """Fonction f(x) = 2x + 3"""
f est le nom de la fonction
return 2 * x + 3
x est le paramètre d'entrée (la variable) # Utilisation
2x + 3 est le calcul fait par la fonction print(f(5)) # Affiche: 13
Exemple : Si x = 5, alors f(5) = 2×5 + 3 = 13
Comparaison Mathématiques ↔ Python
Concept Mathématiques Python
définition f def f
Entrée f(x) def f(x):
Calcul 2x + 3 resultat = 2 * x + 3
Sortie Résultat calculé return resultat
Utilisation f(5) = 13 f(5) → 13
Un programme vers une fonction
def min(a,b):
dans les programmes, on s’est habitué if a<b:
à utiliser “input” pour saisir les valeurs m=a
et print pour afficher le résultat. else:
m=b
a = int(input()) return m
b = int(input())
if a<b: les entrées (a,b) du programme sont
m=a devenues les paramètres de la fonction
else: min.
m=b
print(m) le résultat “m” du programme affiché
par print est maintenant retourné par
l’instruction ‘return’
Exemples de fonctions mathématiques en Python
1. Fonction carré : f(x) = x² 2. Fonction affine : f(x) = ax + b
def carre(x): def affine(x, a, b):
return x ** 2 return a * x + b
print(f"Le carré de 5 est {carre(5)}") # 25 # f(x) = 3x + 2
print(f"f(0) = {affine(0, 3, 2)}") # 2
print(f"Le carré de 10 est {carre(10)}") # 100
print(f"f(1) = {affine(1, 3, 2)}") # 5
3. Fonction valeur absolue : f(x) = |x| 4. Fonction avec plusieurs variables : f(x, y) = x² + y²
def valeur_absolue(x): def somme_carres(x, y):
if x < 0: return x**2 + y**2
return -x
else:
return x print(f"f(3, 4) = {somme_carres(3, 4)}")
# 9 + 16 = 25
print(f"|5| = {valeur_absolue(5)}") # 5
print(f"|-5| = {valeur_absolue(-5)}") # 5
Fonction lambda : lambda arguments: expression
Une fonction lambda (ou lambda) est un moyen de créer des fonctions en une seule ligne
qui transforme les entrées (arguments) en sortie ( moyennant une expression de calcul)
1. Fonction carré : f(x) = x² 2. Fonction affine : f(x) = ax + b
carre = lambda x : x*x affine = lambda x,a,b : a*x + b
print(f"Le carré de 5 est {carre(5)}") # 25 print(f"f(0) = {affine(0, 3, 2)}") # 2
print(f"Le carré de 10 est {carre(10)}") # 100 print(f"f(1) = {affine(1, 3, 2)}") # 5
3. Fonction valeur absolue : f(x) = |x| 4. Fonction avec plusieurs variables : f(x, y) = x² + y²
vabs = lambda x : x if x>0 else -x
somme_carre = lambda x,y : x*x + y*y
print(f"|5| = {valeur_absolue(5)}") # 5
print(f"|-5| = {valeur_absolue(-5)}") # 5 print(f"f(3, 4) = {somme_carres(3, 4)}") # 9 + 16 = 25
Les avantages des fonctions
Réutilisabilité : Définir une fois, utiliser plusieurs fois Lisibilité : Décomposer un programme complexe en blocs
logiques
● En maths : f(x) = x² peut être utilisé pour f(1), f(2), f(3)...
● En Python : même principe ! Maintenabilité : Modifier le code à un seul endroit
Abstraction : Cacher la complexité Testabilité : Tester chaque fonction indépendamment
● En maths : √x cache le processus de calcul de la racine
carrée
● En Python : une fonction cache les détails du calcul
Composition : Combiner des fonctions
● En maths : g(f(x)) - fonction composée
● En Python : g(f(x)) - même chose !
Pourquoi c'est utile en programmation ?
Les fonctions évitent la répétition de code, tout Code optimisé avec fonction
comme en maths on n'écrit pas la formule à chaque
fois ! def calcul_ttc(prix_ht, taux_tva):
prix_ttc = prix_ht * (1 + taux_tva)
# Calcul du prix TTC de trois produits - code return prix_ttc
répétitif
prix_ht1, tva1 = 100, 0.20 # Utilisation simple et claire
prix_ttc1 = prix_ht1 * (1 + tva1) print(f"Prix TTC produit 1: {calcul_ttc(100, 0.20)}€")
print(f"Prix TTC produit 1: {prix_ttc1}€") print(f"Prix TTC produit 2: {calcul_ttc(250, 0.20)}€")
print(f"Prix TTC produit 3: {calcul_ttc(75, 0.20)}€")
prix_ht2, tva2 = 250, 0.20
prix_ttc2 = prix_ht2 * (1 + tva2)
print(f"Prix TTC produit 2: {prix_ttc2}€")
prix_ht3, tva3 = 75, 0.20
prix_ttc3 = prix_ht3 * (1 + tva3)
print(f"Prix TTC produit 3: {prix_ttc3}€")
Syntaxe de base d'une fonction
def nom_fonction(parametre1, parametre2): def celsius_vers_fahrenheit(celsius):
"""
"""Documentation de la fonction (docstring)""" Convertit une température de Celsius en Fahrenheit
"""
# Corps de la fonction fahrenheit = (celsius * 9/5) + 32
return fahrenheit
instruction<1>
# Utilisation
instruction<2> temp1 = 25
print(f"{temp1}°C = {celsius_vers_fahrenheit(temp1)}°F")
instruction<3>
temp2 = 0
… print(f"{temp2}°C = {celsius_vers_fahrenheit(temp2)}°F")
instruction<n> temp3 = 100
print(f"{temp3}°C = {celsius_vers_fahrenheit(temp3)}°F")
return resultat # Optionnel
Fonctions itératives
Les fonctions itératives utilisent des boucles (for, while) pour répéter des opérations.
Exemple 1 : Somme des nombres de 1 à n Exemple 2 : Factorielle itérative
def somme(n): def factoriel(n):
s= 0 f=1
for i in range(1, n + 1): for i in range(2, n + 1):
s= s+ i f=f*i
return s return f
print(f"Somme de 1 à 5: {somme(5)}") # 15
print(f"5! = {factoriel(5)}") # 120
print(f"7! = {factoriel(7)}") # 5040
print(f"Somme de 1 à 10: {somme(10)}") # 55
Retour d’une fonction: Instruction return
En Python, l’instruction return est def pgcd(a,b):
utilisée seulement à l'intérieur d’une m = min(a,b)
fonction pour: for i in range(m,0,-1):
if a%i==b%i==0:
- Renvoyer une valeur au code
return i
appelant.
- Terminer l’exécution de la fonction Itération décroissante : parcours de min(a,b) à 1.
immédiatement. Arrêt immédiat : au premier i qui divise a ET b, c'est
le PGCD.
return i : termine simultanément la boucle ET la
fonction.
fonction récursive
Une fonction récursive est une fonction qui s'appelle elle-même pour résoudre un
problème plus petit.
Exemple Fondamental : Factorielle
Concept de base
Définition mathématique :
Une fonction récursive a toujours deux
parties essentielles : 0! = 1 # case de base : fact(0) = 1
n! = n × (n-1)! # cas récursif:
1. Le cas de base (condition d'arrêt) :
la condition qui arrête la récursion fact(n) = fact(n-1) * n
2. Le cas récursif : l'appel de la Implémentation récursive :
fonction à elle-même avec des
paramètres modifiés def fact(n):
if n==0: return 1
return fact(n-1) * n
Fonction récursive : exécution
fact(3) la récursivité s'est arrêtée à fact(0).
= 3 * fact(2) on n’a pas fait:
= 3 * (2 * fact(1)) fact(0) = fact(-1) * 0
= 3 * (2 * (1 * fact(0))) en effet:
= 3 * (2 * (1 * 1)) fact(0) = 0! = 1
ce n’est pas à calculer car c’est donné
=6
(c’est le point d'arrêt).
Exemples récursivité : pgcd
pgcd(a, b) pgcd(12, 18) = pgcd(18, 12%18 = 12)
maths: pgcd(18,12) = pgcd(12, 18%12 = 6)
cas récursif : pgcd(a,b) = pgcd(b, a%b)
pgcd(12, 6) = pgcd(6, 12%6 = 0)
cas d'arrêt : pgcd(a,0) = a
pgcd(6, 0) = 6 # point d'arrêt
python:
def pgcd(a,b):
if b==0: return a
return pgcd(b,a%b)
Exemples récursivité : somme des chiffres de x
sc(x) = somme chiffres de x IDEE : 7453 = 745*10 + 3
sc(7453) = sc(745) + 3 (=7453%10)
maths:
sc(745) = sc(74) + 5 (= 745 % 10)
cas récursif : sc(x) = sc(//10) + x%10
sc(74) = sc(7) + 4(= 74 % 10)
cas d'arrêt : sc(0) = 0 sc(7) = sc(7//10 = 0) + 7 (= 7 % 10)
python: sc(0) = 0
scc(7) = sc(0) + 7 = 7
def sc(x):
sc(74) = sc(7) + 4 = 7 + 4 = 11
if x==0: return 0
sc(745) = sc(74) + 5 = 11 + 5 = 16
return sc(//10) + x%10 sc(7453) = sc(745) + 3 = 16 + 3 = 19
Notion de module
Un module est un fichier python * Importer tout le module.
contenant des définitions de classes,
import math
constantes et fonctions.
a = [Link]([Link]/3)
Python vient avec des centaines de print(a)
modules qui sont déjà définis :
math, random, time, os, … * Importer les éléments à utiliser
pour utiliser les éléments définis à from math import pi, sin , cos
l'intérieur d’un module, if faut les c, s = cos(pi/4), sin(pi/4)
importer print(c,s)