Une fonction constitue un bloc de code autonome et réutilisable, conçu pour encapsuler une logique métier ou une procédure technique précise. En regroupant des instructions relatives à une seule responsabilité, les fonctions favorisent la modularité, limitent la duplication du code et améliorent considérablement sa lisibilité.

Définition et cycle d'exécution

La déclaration d'une fonction s'opère à l'aide du mot-clé def, suivi d'un identificateur significatif et d'une paire de parenthèses. Le corps de la fonction est délimité par une indentation cohérente. Contrairement à une séquence d'instrucsions linéaires, une fonction reste inerte jusqu'à ce qu'elle soit explicitement invoquée.

def initialiser_moteur():
    print("Vérification des dépendances...")
    print("Chargement des modules critiques.")
    print("Système prêt.")

# La fonction n'exécute ses instructions qu'à l'appel
initialiser_moteur()

Mécanismes de retour

L'instruction return permet de transférer un résultat à l'appelant et interrompt immédiatement l'exécution du bloc fonctionnel. Tout code situé après un return sera ignoré. Si plusieurs valeurs sont spécifiées, Python les empaquete automatiquement dans un tuple.

def valider_connexion(utilisateur, token):
    print("Authentification en cours...")
    if not token:
        return "Échec", "Jeton manquant"
    
    print("Accès autorisé.")
    return "Succès", [utilisateur, token]

# Récupération des valeurs retournées
etat, details = valider_connexion("admin", "xyz-123")
print(etat)  # Affiche : Succès

Gestion des paramètres et arguments

La distinction entre paramètres formels (définis lors de la déclaration) et arguments effectifs (fournis lors de l'appel) est fondamentale. Python offre plusieurs mécanismes pour transmettre ces données :

• Arguments positionnels : La correspondance s'effectue strictement de gauche à droite selon l'ordre de déclaration.
• Arguments nommés (keyword) : Permettent d'assigenr explicitement une valeur à un paramètre, indépendamment de son positionnement.
• Arguments mixtes : Il est possible de combiner les deux approches, sous réserve que les argumants positionnels précèdent systématiquement les arguments nommés.

def generer_rapport(client, format_sortie, verbose=False):
    print(f"Traitement pour : {client}")
    if verbose:
        print("Mode détaillé activé.")
    return f"Rapport {format_sortie} généré."

# Appel avec positionnement classique
generer_rapport("Alpha Corp", "PDF")

# Utilisation d'arguments nommés
generer_rapport(format_sortie="CSV", client="Beta Ltd")

# Combinaison mixte (positionnel puis nommé)
generer_rapport("Gamma Inc", verbose=True, format_sortie="JSON")

Valeurs par défaut et optimisation

Définir des valeurs par défaut pour les paramètres formels permet de rendre certains arguments optionnels lors de l'appel. Cette technique est particulièrement utile pour les configurations standardisées. Lorsqu'une valeur est fournie explicitement, elle surcharge la valeur par défaut.

def configurer_serveur(hostname, port=8080, protocol="https"):
    return f"Connexion vers {hostname}:{port} via {protocol}"

# Utilisation de la valeur par défaut
print(configurer_serveur("api.example.com"))

# Surcharge ciblée des paramètres
print(configurer_serveur("db.internal", protocol="tcp", port=5432))