Types en Python

Cet article explique les types en Python.

YouTube Video

Types en Python

Le module typing en Python est utilisé pour introduire des annotations de type dans Python. Il a été initialement introduit dans Python 3.5 et il est utilisé pour améliorer la lisibilité et la maintenabilité du code. Les annotations de type n'affectent pas l'exécution du code mais permettent la vérification des types avec les IDEs et les outils d'analyse statique.

Notions de base sur les annotations de type

Les annotations de type clarifient l'intention du code en spécifiant explicitement les types des fonctions et des variables. Dans l'exemple ci-dessous, les types sont spécifiés pour les arguments et la valeur de retour.

1def add_numbers(a: int, b: int) -> int:
2    return a + b
3
4result: int = add_numbers(5, 10)
5print(result)  # 15

Dans le code ci-dessus, a et b sont de type entier (int), et la valeur de retour de la fonction est également explicitement indiquée comme un entier. Même avec des annotations de type, les types ne sont pas strictement appliqués, mais des avertissements peuvent s'afficher en cas d'incompatibilité de type pendant le développement.

Annotations de type essentielles

Le module typing en Python fournit diverses classes et fonctions pour définir des annotations de type. Voici une liste des annotations de type les plus courantes.

• int: entier
• str: chaîne de caractères
• float: nombre à virgule flottante
• bool: booléen
• List: liste
• Dict: dictionnaire
• Tuple: tuple
• Set: ensemble

Type List

Le type de liste est spécifié à l'aide de la classe List. Vous pouvez également spécifier explicitement le type des éléments d'une liste.

1from typing import List
2
3def sum_list(numbers: List[int]) -> int:
4    return sum(numbers)
5
6print(sum_list([1, 2, 3]))  # 6

Dans cet exemple, tous les éléments de la liste doivent être de type int.

Type Dict

Un type dictionnaire est défini à l'aide de Dict. Les types des clés et des valeurs peuvent être spécifiés.

1from typing import Dict
2
3def get_student_age(students: Dict[str, int], name: str) -> int:
4    return students.get(name, 0)
5
6students = {"Alice": 23, "Bob": 19}
7print(get_student_age(students, "Alice"))  # 23

Dans cet exemple, le dictionnaire utilise str comme type de clé et int comme type de valeur.

Type Tuple

Les tuples sont spécifiés à l'aide du type Tuple. Vous pouvez spécifier individuellement le type de chaque élément d'un tuple.

1from typing import Tuple
2
3def get_person() -> Tuple[str, int]:
4    return "Alice", 30
5
6name, age = get_person()
7print(name, age)  # Alice 30

Ici, la fonction get_person renvoie un tuple contenant une chaîne de caractères et un entier.

Type Union

Le type Union est utilisé pour indiquer explicitement que plusieurs types sont acceptables.

1from typing import Union
2
3def process_value(value: Union[int, float]) -> float:
4    return value * 2.0
5
6print(process_value(10))  # 20.0
7print(process_value(3.5))  # 7.0

Dans cet exemple, la fonction process_value accepte un int ou un float en argument et renvoie un résultat de type float.

Type Optional

Le type Optional est utilisé lorsqu'une variable peut être None. Il est fourni comme une abréviation pour Union[Type, None].

1from typing import Optional
2
3def greet(name: Optional[str] = None) -> str:
4    if name is None:
5        return "Hello, Guest!"
6    return f"Hello, {name}!"
7
8print(greet())  # Hello, Guest!
9print(greet("Alice"))  # Hello, Alice!

Ici, cela montre que lorsque name n'est pas spécifié, il est traité comme None.

Types génériques

Les types génériques sont un moyen de représenter abstraitement le type d'éléments contenus dans une structure de données. Dans le module typing, vous pouvez définir des types génériques à l'aide de TypeVar.

1from typing import TypeVar, List
2
3T = TypeVar('T')
4
5def get_first_element(elements: List[T]) -> T:
6    return elements[0]
7
8print(get_first_element([1, 2, 3]))  # 1
9print(get_first_element(["a", "b", "c"]))  # a

Dans cet exemple, get_first_element est une fonction qui renvoie le premier élément d'une liste, et cela fonctionne quel que soit le type de cette liste.

Alias de type

Un alias de type est un moyen de simplifier des définitions de types complexes en leur donnant un nom clair.

1from typing import List, Tuple
2
3Coordinates = List[Tuple[int, int]]
4
5def get_coordinates() -> Coordinates:
6    return [(0, 0), (1, 1), (2, 2)]
7
8print(get_coordinates())  # [(0, 0), (1, 1), (2, 2)]

Dans cet exemple, un alias de type Coordinates est défini pour représenter simplement un type contenant des tuples dans une liste.

Résumé

Le module typing en Python est très utile pour améliorer la lisibilité et la maintenabilité du code. En utilisant correctement les annotations de type, vous pouvez aider à prévenir les incompatibilités de type et les bogues, en particulier dans les projets à grande échelle ou le développement en équipe. Les types ne sont qu'un outil de support au développement et n'affectent pas le comportement à l'exécution, préservant ainsi la flexibilité du code.

Vous pouvez suivre l'article ci-dessus avec Visual Studio Code sur notre chaîne YouTube. Veuillez également consulter la chaîne YouTube.

YouTube Video