Les Fonctions

en Python
Concepts fondamentaux, typage, modules et applications métiers

1. Définition 2. Paramètres 3. Type Hints 4. Portée

5. Built-ins 6. Lambda 7. Modules 8. main()

 01
Introduction & Concepts de Base
Qu'est-ce qu'une fonction ? Pourquoi utiliser des fonctions ?
Réutilisabilité
Un bloc de code réutilisable qui effectue une tâche spécifique. Elle
Écrire une fois, utiliser plusieurs fois
peut prendre des entrées (paramètres) et retourner un résultat.

# Syntaxe de base Modularité

def nom_fonction(param1, param2): Découper le code en blocs logiques
"""Docstring optionnelle."""
# corps de la fonction
return résultat
Lisibilité
# Appel de la fonction Nommer clairement chaque action
resultat = nom_fonction(val1, val2)

Débogage
Isoler et tester chaque partie

Convention : noms de fonctions en snake_case — ex: calculer_moyenne(), lire_fichier()

 02
Paramètres, Arguments & Retour de Valeur
Positionnels Par défaut

def add(a, b): def saluer(nom, msg='Bonjour'):

return a + b return f'{msg}, {nom}!'
add(3, 5) # → 8 saluer('Alice') # → 'Bonjour, Alice!'

*args **kwargs

def somme(*nombres): def profil(**infos):

return sum(nombres) for k,v in [Link]():
somme(1,2,3,4) # → 10 print(f'{k}: {v}')

Retour multiple avec tuple : Pas de return → None :

def min_max(lst): return min(lst), max(lst) def afficher(msg): print(msg)
 03
Le Typage Indicatif (Type Hinting)
Introduit en Python 3.5+ (PEP 484). Améliore la lisibilité et active l'aide des IDEs — mais non obligatoire à l'exécution.

Sans Type Hinting Avec Type Hinting

def calculer_tva(prix, taux): def calculer_tva(

# Que sont prix et taux ? prix: float,
# float ? int ? str ? taux: float = 0.20
return prix * (1 + taux) ) -> float:
return prix * (1 + taux)

Types courants
int / float / str / bool list[int] dict[str, float]
Types primitifs standard Liste d'entiers Dictionnaire str → float

tuple[int, str] Optional[str] Union[int, str]

Tuple typé str ou None (typing) int OU str (typing)

from typing import Optional

def chercher(nom: str) -> Optional[str]:
# retourne str ou None
return base_donnees.get(nom)
 04
Portée des Variables (Scope)
Règle LEGB — ordre de recherche d'un nom Python :

Local
L Variables définies dans la fonction courante

Enclosing
E Variables dans les fonctions imbriquées parentes

Global
G Variables au niveau du module (script)

Built-in
B Noms prédéfinis Python (print, len, range…)

Mots-clés global et nonlocal

compteur = 0 # variable globale

def incrementer():
global compteur # déclare qu'on modifie le global
compteur += 1

def externe():
 05
Les Fonctions Prédéfinies (Built-in Functions)
Entrées/Sorties Types & Conversion Mathématiques

print() input() int() float() abs() round()

open() str() bool() pow() min()

list() dict() max() sum()

Itérables Objets & Types Fonctionnels

len() range() type() isinstance() map() filter()

enumerate() zip() id() dir() any() all()

sorted() reversed() help()

notes = [14, 17, 12, 19, 8]

print(f'Nb élèves : {len(notes)}, Moy : {round(sum(notes)/len(notes), 1)}')
 06
Les Fonctions Anonymes (Lambda)

param1,
lambda : expression
mot-clé
param2
paramètres résultat

Cas d'usage courants Lambda vs def ?

# Tri par clé Lambda si…

etudiants = [('Alice',16),('Bob',14),('Claire',18)]
tries = sorted(etudiants, key=lambda x: x[1]) • Expression simple (1 ligne)
• Utilisé comme argument
# Avec map() et filter()
carres = list(map(lambda n: n**2, range(10))) • Aucun nom nécessaire
pairs = list(filter(lambda n: n%2==0, range(10))) • Usage ponctuel

# Opération rapide
double = lambda x: x * 2
print(double(7)) # → 14
def si…
• Logique complexe
• Réutilisation multiple
• Docstring nécessaire
• Meilleure lisibilité
 07
Création & Organisation de Modules Personnalisés
Structure de projet recommandée Différentes formes d'import

mon_projet/ # Importer le module entier

├── [Link] # point d'entrée import calculs
├── [Link] # fonctions mathématiques calculs.calculer_ttc(100)
├── [Link] # fonctions utilitaires
└── [Link] # constantes & config # Importer des fonctions spécifiques
from calculs import calculer_ttc
calculer_ttc(100)

Module [Link] # Alias (pour les noms longs)

import calculs as calc
calc.calculer_ttc(100)
"""Module de calculs financiers."""
# Importer tout (déconseillé !)
TVA = 0.20 # constante du module from calculs import *

def calculer_ttc(prix_ht: float) -> float:

"""Calcule le prix TTC."""
return prix_ht * (1 + TVA)

# [Link] — contrôler l'export public

__all__ = ['calculer_ttc', 'TVA'] # seules ces noms exportés

Un fichier .py = un module. Un dossier avec __init__.py = un package.

 08
La Structure Standard : La Fonction main()
Pourquoi if __name__ == '__main__' ? Modèle complet recommandé

"""Module de gestion des notes."""

Script autonome
Exécuter du code uniquement quand le fichier est lancé directement def charger_notes(fichier: str) -> list[float]:
"""Charge les notes depuis un fichier."""
# ...
return []
Module importable
Évite l'exécution lors d'un import par un autre module def calculer_moyenne(notes: list[float]) -> float:
"""Calcule la moyenne."""
return sum(notes) / len(notes) if notes else 0

Testabilité def afficher_rapport(notes: list[float]) -> None:

"""Affiche le rapport complet."""
Les fonctions restent testables indépendamment moy = calculer_moyenne(notes)
print(f'Moyenne : {moy:.2f}')

def main() -> None:

Flux d'exécution :
notes = charger_notes("[Link]")
afficher_rapport(notes)
1. Python charge le module
if __name__ == '__main__':
2. Évalue __name__ main()

3. == '__main__' ? → Oui si lancé directement

4. main() est appelé

09
Applications Métiers par Spécialité
Finance Santé Data Science

def rentabilite(achat, vente): def calcul_imc(poids, taille): def normaliser(data: list):

return (vente- return poids / taille**2 m=min(data); M=max(data)
achat)/achat*100 return [(x-m)/(M-m) for x in
data]

Web IA / ML Système

def valider_email(email: str): def sigmoid(x: float) -> float: def lire_csv(chemin: str):
return "@" in email and "." import math with open(chemin) as f:
in email return 1/(1+[Link](-x)) return [Link]()
 10
Travaux Dirigés (TD) & Solutions
TD 1 Calcul de BMI Débutant

Écrire une fonction bmi(poids, taille) qui retourne le BMI et sa catégorie.

def bmi(poids: float, taille: float) -> tuple[float, str]:

imc = poids / taille**2
if imc < 18.5: cat = "Sous-poids"
elif imc < 25: cat = "Normal"
else: cat = "Surpoids"
return round(imc, 2), cat

TD 2 Décorateur Minuterie Avancé

Créer un décorateur @minuterie qui mesure le temps d'exécution de toute fonction.

import time
def minuterie(func):
def wrapper(*args, **kwargs):
debut = [Link]()
res = func(*args, **kwargs)
print(f'{func.__name__}: {[Link]()-debut:.4f}s')
return res
return wrapper
Récapitulatif
Ce qu'il faut retenir
def Lambda
Définir des fonctions nommées, réutilisables, documentées
λ Fonctions courtes anonymes pour map/filter/sorted

Paramètres Modules
Positionnels, par défaut, *args, **kwargs — flex totale Organiser en fichiers .py, contrôler les imports

Type Hints __main__

Annoter les types pour plus de clarté et d'aide IDE Point d'entrée standard, code testable et importable

Portée LEGB
Local → Enclosing → Global → Built-in

"La maîtrise des fonctions est la clé d'un code Python propre, modulaire et professionnel."