Le vieux ferry grinçait sur les eaux noires de l'Hudson. Un contact m'avait donné rendez-vous ici. "Une fonction discrète", avait-il dit. Une opération autonome, avec des entrées, des traitements, une sortie. Un petit univers logique qu'on peut appeler, encore et encore, sans jamais connaître ses secrets intérieurs. Les fonctions. Le cœur du métier.
Définition d'une fonction
Définir une fonction, c'est créer un protocole. Une manière standardisée de faire une chose précise.
def nettoyer_la_scene(lieu, methode):
"""
Opération de nettoyage standard.
"""
instructions = f"Nettoyage {methode} initié à {lieu}"
print(instructions)
# ... le vrai travail est ici, invisible
return "nettoyage_terminé"
Le mot-clé def. Puis le nom. Des parenthèses. Des paramètres. Un deux-points. Le corps indenté. Une fonction se déclare. Elle attend son heure.
Paramètres et valeurs de retour
Les paramètres, ce sont les informations qu'on lui donne à manger. La valeur de retour, c'est ce qu'elle recrache.
def calculer_compensation(risque, duree, acompte=10000):
"""Calcule le montant final."""
total = acompte + (risque * duree * 1500)
return total
On peut avoir des paramètres obligatoires. Des paramètres avec des valeurs par défaut. La fonction s'adapte. Elle prend ce qu'on lui donne, fait son calcul, rend un résultat. Propre.
Portée des variables
C'est la règle fondamentale : ce qui se passe dans la fonction reste dans la fonction.
argent_caisse = 50000 # Variable globale. Tout le monde la voit.
def transaction_interne(montant):
compteur_secret = 0 # Variable locale. N'existe QUE dans la fonction.
compteur_secret += 1
nouveau_solde = argent_caisse - montant
return nouveau_solde
# À l'extérieur, `compteur_secret` n'existe pas. C'est un fantôme.
# `argent_caisse` peut être lue, mais modifiée ? C'est une autre histoire.
La fonction est une boîte noire. Elle peut utiliser des informations de l'extérieur, mais son travail interne, ses variables temporaires, disparaissent quand elle se termine. C'est la discrétion institutionnalisée.
Fonctions lambda
L'outil jetable. La fonction anonyme, créée pour une tâche immédiate, puis oubliée.
# Au lieu de définir une fonction complète pour un tri spécifique :
tri_par_danger = lambda agent: agent["niveau_alerte"]
liste_agents_triee = sorted(liste_agents, key=tri_par_danger, reverse=True)
Une ligne. Pas de nom. Juste une opération rapide, souvent utilisée comme argument pour une autre fonction (sorted, filter, map). Élégant. Éphémère.
Documentation avec docstrings
Les triples guillemets. La note qu'on laisse dans le dossier. Pas pour la machine, pour l'humain qui reprendra le code après vous. Ou pour vous, dans six mois, quand vous aurez tout oublié.
def extraire_info(cible, source="reseau_interne", force=False):
"""
Extrait les informations sensibles sur une cible.
Args:
cible (str): Nom de code ou identité de la cible.
source (str): Source des données ('reseau_interne', 'gris', 'noir').
force (bool): Contourne les vérifications de sécurité. Dangereux.
Returns:
dict: Un dictionnaire d'informations, ou None si échec.
Raises:
SurveillanceError: Si la requête est détectée.
"""
# ... l'implémentation sournoise ici ...
pass
Le docstring explique l'intention, les attentes, les conséquences. C'est la mémoire de la fonction. Sa légende. Dans ce métier, une bonne documentation peut vous sauver la vie. Ou condamner quelqu'un d'autre.
Le ferry a accosté. L'homme est descendu, un attaché-case à la main. Il m'a jeté un regard, a hoché la tête. L'opération était terminée. Il avait exécuté sa fonction. Des entrées (le lieu, l'heure), un traitement (l'échange), une sortie (l'attaché-case). Propre.
Je suis resté sur le pont, le vent froid dans le cou. Les fonctions. Des machines logiques autonomes. Vous les alimentez, elles travaillent, elles rendent un résultat. Vous n'avez pas besoin de savoir comment elles font, tant qu'elles font. C'est la beauté de l'abstraction.
Et dans un monde où trop de savoir peut être mortel, c'est une sécurité appréciable.
Découper le chaos en procédures propres.