Python - Function Annotations: A Beginner's Guide

Bonjour, aspirants programmeurs Python !aujourd'hui, nous allons plonger dans le monde fascinant des annotations de fonctions. Ne vous inquiétez pas si vous êtes nouveau dans la programmation – je vais vous guider à travers ce concept pas à pas, tout comme j'ai fait pour dizaines d'étudiants au fil des années. Alors, prenez votre boisson préférée, mettez-vous à l'aise, et partons ensemble dans cette aventure Python !

Qu'est-ce qu'une annotation de fonction ?

Les annotations de fonctions sont une fonctionnalité en Python qui permet d'ajouter des métadonnées aux paramètres de fonction et aux valeurs de retour. Pensez-y comme de petites notes que nous accrochons à nos fonctions pour fournir des informations supplémentaires. Elles n'affectent pas le fonctionnement de la fonction, mais peuvent être très utiles pour la documentation et le contrôle de type.

Commençons par un exemple simple :

def saluer(nom: str) -> str:
return f"Bonjour, {nom} !"

Dans cet exemple, : str après nom est une annotation suggérant que nom devrait être une chaîne de caractères. Le -> str à la fin suggère que la fonction retournera une chaîne de caractères.

Pourquoi utiliser des annotations de fonction ?

1. Elles rendent votre code plus lisible.
2. Elles aident les autres développeurs (et vous à l'avenir !) à mieux comprendre votre code.
3. Elles peuvent être utilisées par des outils de contrôle de type pour attraper des erreurs potentielles.

Maintenant, plongeons plus profondément dans différents types d'annotations !

Annotations de fonction avec des paramètres

Nous pouvons annoter les paramètres de fonction pour indiquer le type de données que nous attendons. Voici un exemple :

def calculer_surface(longueur: float, largeur: float) -> float:
return longueur * largeur

Dans cette fonction, nous disons que longueur et largeur devraient être des flottants (nombres décimaux), et que la fonction retournera un flottant.

Essayons de l'utiliser :

surface = calculer_surface(5.5, 3.2)
print(f"La surface est : {surface}")

Sortie :

La surface est : 17.6

N'oubliez pas que ces annotations ne contraignent pas les types – vous pourriez toujours appeler calculer_surface("bonjour", "monde"), mais cela n'aurait pas beaucoup de sens !

Annotations de fonction avec le type de retour

Nous avons déjà vu l'annotation -> float pour le type de retour, mais examinons un exemple plus complexe :

def obtenir_infos_utilisateur(user_id: int) -> dict:
# Imaginez que cette fonction récupère les données utilisateur d'une base de données
return {
"id": user_id,
"nom": "Alice",
"âge": 30,
"email": "[email protected]"
}

utilisateur = obtenir_infos_utilisateur(12345)
print(f"Nom de l'utilisateur : {utilisateur['nom']}")

Sortie :

Nom de l'utilisateur : Alice

Ici, nous indiquons que la fonction prend un entier user_id et retourne un dictionnaire.

Annotations de fonction avec des expressions

Les annotations ne doivent pas nécessairement être des types simples – elles peuvent être des expressions plus complexes également. Voici un exemple :

from typing import List, Union

def traiter_articles(articles: List[Union[int, str]]) -> List[str]:
return [str(article).upper() pour article dans articles]

resultat = traiter_articles([1, "bonjour", 42, "monde"])
print(resultat)

Sortie :

['1', 'BONJOUR', '42', 'MONDE']

Dans cet exemple, List[Union[int, str]] signifie que la fonction attend une liste où chaque élément peut être un entier ou une chaîne de caractères.

Annotations de fonction avec des arguments par défaut

Nous pouvons combiner les annotations avec des arguments par défaut. Voici comment :

def saluer_utilisateur(nom: str = "Invité") -> str:
return f"Bienvenue, {nom} !"

print(saluer_utilisateur())
print(saluer_utilisateur("Alice"))

Sortie :

Bienvenue, Invité !
Bienvenue, Alice !

Dans cette fonction, nous disons que nom devrait être une chaîne de caractères, et si aucun nom n'est fourni, il est par défaut "Invité".

Mettre tout ensemble

Maintenant, examinons un exemple plus complexe qui combine diverses techniques d'annotation :

from typing import List, Dict, Union

def analyser_ventes(donnees: List[Dict[str, Union[str, float]]]) -> Dict[str, float]:
total_ventes = 0.0
articles_vendus = 0

pour transaction dans donnees:
total_ventes += transaction['montant']
articles_vendus += 1

return {
"total_ventes": total_ventes,
"vente_moyenne": total_ventes / articles_vendus si articles_vendus > 0 else 0
}

donnees_ventes = [
{"article": "Widget A", "montant": 10.99},
{"article": "Widget B", "montant": 5.99},
{"article": "Widget C", "montant": 15.99}
]

resultat = analyser_ventes(donnees_ventes)
print(f"Total des ventes : ${resultat['total_ventes']:.2f}")
print(f"Vente moyenne : ${resultat['vente_moyenne']:.2f}")

Sortie :

Total des ventes : $32.97
Vente moyenne : $10.99

Cet exemple montre comment nous pouvons utiliser des annotations complexes pour décrire la structure de nos données d'entrée et de valeur de retour.

Résumé des méthodes d'annotation de fonction

Voici un tableau résumant les différentes manières d'utiliser les annotations de fonction :

Méthode	Exemple	Description
Annotation de paramètre	def func(x: int):	Suggère le type pour un paramètre
Annotation de type de retour	def func() -> str:	Suggère le type de retour de la fonction
Valeur par défaut avec annotation	def func(x: int = 0):	Combine une suggestion de type avec une valeur par défaut
Annotation de type complexe	def func(x: List[int]):	Utilise des types de module typing pour des indices de type plus spécifiques
Multiples types (Union)	def func(x: Union[int, str]):	Suggère qu'un paramètre peut être l'un des plusieurs types

N'oubliez pas que ces annotations sont des indices, pas des règles strictes. Python ne vous empêchera pas d'utiliser des types différents, mais des outils comme mypy peuvent utiliser ces annotations pour attraper des erreurs potentielles avant de exécuter votre code.

Et voilà, mes chers étudiants ! Nous avons parcouru la terre des annotations de fonctions Python. J'espère que ce guide a éclairé ce concept pour vous. N'oubliez pas que la meilleure façon d'apprendre est en pratiquant, alors n'hésitez pas à expérimenter avec ces annotations dans votre propre code. Bon codage, et que vos fonctions soient toujours bien annotées !

Credits: Image by storyset