Réponse.

Historique de la question :

La typage dynamique est caractéristique de Python depuis ses premières versions. Cela signifie que les variables ne sont pas liées à un type de données spécifique à l'avance, contrairement à des langages comme Java ou C++. Le type est déterminé au moment de l'exécution.

Problème :

La principale difficulté est la perte de contrôle explicite des types. Cela complique la détection des erreurs lors de l'écriture du code, ce qui peut conduire à des bugs logiques pendant l'exécution, surtout lors de l'extension du code.

Solution :

Python résout ce problème par la typage à la canard (si un objet se comporte comme un canard, alors c'est un canard) ainsi qu'avec des annotations de type (type hints), mais les annotations ne sont pas obligatoires et ne sont pas vérifiées au moment de l'exécution, seulement par des outils tiers.

Exemple de code :

x = 42      # int
x = "foo"  # maintenant une chaîne

def process(val):
    return val + val

print(process(5))        # 10
print(process("ha"))    # haha

Caractéristiques clés :

• Le type de la variable est déterminé uniquement au moment de l'exécution.
• Les erreurs de type ne sont découvertes que lors de l'exécution du code.
• Flexibilité : une même fonction peut fonctionner avec différents types (mais des erreurs inattendues peuvent survenir).

Questions pièges.

Peut-on utiliser une variable d'abord comme une liste, puis comme un nombre dans un même bloc de code, et cela entraînera-t-il une erreur de syntaxe ?

Oui — il n'y aura pas d'erreur de syntaxe. L'erreur ne surviendra que lors de la tentative d'effectuer une opération invalide avec le nouveau type.

x = [1, 2, 3]
x = 5
# print(x[0])  # L'erreur ne se produira qu'à cet appel

Le type hint en Python garantit-il que la variable aura toujours le type spécifié au moment de l'exécution ?

Non — le type hint n'est qu'une indication, l'interpréteur ne le vérifie pas. Seuls les linters et mypy peuvent vérifier les types.

def foo(x: int) -> int:
    return x + 1

foo("string")  # il n'y aura pas d'erreur avant l'appel

Le type d'une fonction est-il aussi dynamique ? Peut-on modifier la signature d'une fonction au moment de l'exécution ?

Une fonction est un objet de premier ordre. Son type peut être redéfini, mais la signature ne peut pas (il est possible de remplacer la fonction par une nouvelle).

def f():
    return 5
f = lambda: "abc"
print(f())  # 'abc'

Erreurs typiques et anti-patterens

• Utilisation d'une variable d'un type inattendu (par exemple, passé une liste alors qu'une chaîne était attendue).
• Foi excessive dans les type hints en l'absence de vérification statique.
• Négligence des vérifications de types lors du travail avec des données entrantes externes.

Exemple de la vie réelle

Cas négatif

Dans un projet, le type des paramètres d'entrée de la fonction n'était pas vérifié, ce qui a conduit à des données provenant de formulaires utilisateurs au format chaîne, alors qu'elles étaient traitées comme des nombres. Des erreurs imprévisibles sont survenues en production.

Avantages :

Prototypage rapide, fonctions courtes, peu de boilerplate.

Inconvénients :

Difficulté de débogage, erreurs apparaissant aux endroits les plus inattendus et uniquement avec certaines données.

Cas positif

Avec l'utilisation de type hints et la validation statique des types via mypy, les problèmes étaient détectés lors de l'étape CI/CD avant le passage en production.

Avantages :

Détection précoce de problèmes potentiels, maintenance aisée du code.

Inconvénients :

Du temps est consacré à une vérification supplémentaire, parfois un peu de code supplémentaire est ajouté.