Typage Python : Amélioration de la lisibilité du code

Introduction

Dans ce tutoriel, vous allez apprendre à utiliser le module Python typing pour ajouter des indications de type à votre code. Les indications de type aident à rendre votre code plus lisible et maintenable en indiquant explicitement les types d'entrée et de sortie attendus par vos fonctions.

Skills Graph

Types de base

Les indications de type sont une fonctionnalité introduite en Python 3.5, et le module typing a été ajouté en Python 3.5.2 pour fournir un ensemble standard d'annotations de type. Importez les types pertinents à partir du module typing pour commencer à utiliser les indications de type.

from typing import List, Tuple, Dict

Les indications de type pour les types de base sont simples. Utilisez simplement le type lui-même comme indication.

Ouvrez l'interpréteur Python en tapant la commande suivante dans le terminal.

python3

1. Définissez une variable de type int, affectez-lui une valeur et imprimez-la.

age: int = 25
print(age) #Sortie : 25

2. Définissez une variable de type float, affectez une valeur et imprimez-la.

temperature: float = 98.6
print(temperature) ## Sortie : 98.6

3. Définissez une variable de type bool, affectez-lui une valeur et imprimez-la.

is_raining: bool = True
print(is_raining) ## Sortie : True

4. Définissez une variable de type str, affectez une valeur et imprimez-la.

def greet(name: str) -> str:
    return f"Hello, {name}!"

print(greet("Alice")) ## Sortie : Hello, Alice!

5. Définissez une fonction qui prend deux arguments de type int, les multiplie et renvoie le résultat sous forme d'un int.

def multiply(x: int, y: int) -> int:
    return x * y

result = multiply(5, 10)
print(result) ## Sortie : 50

Conteneurs et génériques

Les indications de type pour les types de conteneur (tels que les listes, les dictionnaires et les ensembles) peuvent être plus spécifiques en utilisant les génériques.

Astuce : Les expériences avec les numéros de série 1-3 peuvent être implémentées dans l'interpréteur Python, et les expériences avec le numéro de série 4 sont implémentées dans WebIDE.

1. Définissez une variable de type List[int], affectez quelques valeurs et imprimez-la.

from typing import List
numbers: List[int] = [1, 2, 3, 4, 5]
print(numbers) ## Sortie : [1, 2, 3, 4, 5]

2. Définissez une variable de type Dict[str, int], affectez-lui quelques paires clé-valeur et imprimez-la.

from typing import Dict
ages: Dict[str, int] = {"Alice": 25, "Bob": 30, "Charlie": 35}
print(ages) ## Sortie : {'Alice': 25, 'Bob': 30, 'Charlie': 35}

3. Définissez une variable de type Tuple[str, int, float], affectez-lui quelques valeurs et imprimez-la.

from typing import Tuple
person: Tuple[str, int, float] = ("Alice", 25, 5.7)
print(person) ## Sortie : ('Alice', 25, 5.7)

4. Définissez une fonction qui prend une liste d'entiers en argument et renvoie le résultat sous forme d'un nouvel ensemble d'entiers.

Créez un projet appelé list_to_set.py dans WebIDE et entrez le contenu suivant.

from typing import List, Set

def get_unique_elements(elements: List[int]) -> Set[int]:
    return set(elements)

numbers = [1, 2, 2, 3, 4, 4, 4, 5]
unique_numbers = get_unique_elements(numbers)
print(unique_numbers)  ## Sortie : {1, 2, 3, 4, 5}

Utilisez la commande suivante pour exécuter le script.

python list_to_set.py

Types définis par l'utilisateur

Vous pouvez également utiliser des types et des classes personnalisées comme indications de type.

Astuce : Cette expérience est implémentée dans WebIDE.

1. Définissez une classe Person avec des attributs typés name (str) et age (int) et une méthode get_summary qui renvoie une chaîne résumant le nom et l'âge de la personne.

Créez un projet appelé str_and_int_to_str.py dans WebIDE et entrez le contenu suivant.

class Person:
    def __init__(self, name: str, age: int):
        self.name = name
        self.age = age
    def get_summary(self) -> str:
        return f"{self.name} est âgé de {self.age} ans."

person1 = Person("Alice", 25)
print(person1.get_summary()) ## Sortie : Alice est âgé de 25 ans.

Utilisez la commande suivante pour exécuter le script.

python str_and_int_to_str.py

2. Définissez une classe Point avec des attributs typés x et y, tous deux de type float et une méthode distance qui prend un autre point en argument et renvoie la distance entre les deux points.

Créez un projet appelé other_to_float.py dans WebIDE et entrez le contenu suivant.

import math

class Point:
    def __init__(self, x: float, y: float):
        self.x = x
        self.y = y
    def distance(self, other: "Point") -> float:
        return math.sqrt((self.x - other.x)**2 + (self.y - other.y)**2)

point1 = Point(0, 0)
point2 = Point(3, 4)
print(point1.distance(point2)) ## Sortie : 5.0

Utilisez la commande suivante pour exécuter le script.

python other_to_float.py

Alias de type

Les alias de type peuvent créer des indications de type plus lisibles, en particulier pour les types complexes.

Créez un projet appelé type_aliases.py dans WebIDE et entrez le contenu suivant.

from typing import List, Tuple

Coordinate = Tuple[float, float]
Path = List[Coordinate]

def get_distance(coord1: Coordinate, coord2: Coordinate) -> float:
    return ((coord1[0] - coord2[0])**2 + (coord1[1] - coord2[1])**2)**0.5

start = (0, 0)
end = (3, 4)
print(get_distance(start, end))  ## Sortie : 5.0

Utilisez la commande suivante pour exécuter le script.

python type_aliases.py

Optionnel et None

Le type Optional peut être utilisé lorsqu'une valeur peut être soit d'un type spécifique, soit None.

1. Définissez une fonction qui prend un argument int optionnel, le multiplie par 2 s'il n'est pas None, et renvoie le résultat sous forme d'un int ou None si l'entrée était None.

Créez un projet appelé option_and_none_1.py dans WebIDE et entrez le contenu suivant.

from typing import Optional

def double_or_none(number: Optional[int]) -> Optional[int]:
    if number is not None:
        return number * 2
    else:
        return None

result1 = double_or_none(5)
result2 = double_or_none(None)
print(result1, result2) ## Sortie : 10 None

Utilisez la commande suivante pour exécuter le script.

python option_and_none_1.py

2. Définissez une classe Person avec un attribut typé address, soit une chaîne d'adresse valide, soit None.

Créez un projet appelé option_and_none_2.py dans WebIDE et entrez le contenu suivant.

from typing import Optional

class Person:
    def __init__(self, name: str, age: int, address: Optional[str]):
        self.name = name
        self.age = age
        self.address = address

person1 = Person("Alice", 25, "123 Main St")
person2 = Person("Bob", 30, None)
print(person1.name, person1.age, person1.address) ## Sortie : Alice 25 123 Main St
print(person2.name, person2.age, person2.address) ## Sortie : Bob 30 None

Utilisez la commande suivante pour exécuter le script.

python option_and_none_2.py

Appelable

Le type Callable est utilisé pour spécifier le type d'une fonction ou d'une méthode.

Créez un projet appelé callable.py dans WebIDE et entrez le contenu suivant.

from typing import Callable

def apply_function(value: int, func: Callable[[int], int]) -> int:
    return func(value)

def double(x: int) -> int:
    return x * 2

print(apply_function(5, double))  ## Sortie : 10

Utilisez la commande suivante pour exécuter le script.

python callable.py

TypedDict

TypedDict vous permet de créer des dictionnaires personnalisés avec des clés et des types de valeurs spécifiques.

Astuce : TypedDict a été introduit dans Python 3.8, donc vous devez exécuter Python 3.8 ou une version ultérieure pour l'utiliser.

Voici un exemple :

Créez un projet appelé typeddict.py dans WebIDE et entrez le contenu suivant.

from typing import TypedDict

class PersonInfo(TypedDict):
    name: str
    age: int

def greet(person: PersonInfo) -> str:
    return f"Bonjour, {person['name']}! Vous avez {person['age']} ans."

alice_info: PersonInfo = {"name": "Alice", "age": 30}
print(greet(alice_info))  ## Sortie : Bonjour, Alice! Vous avez 30 ans.

Utilisez la commande suivante pour exécuter le script.

python typeddict.py

Newtype

NewType est une indication de type provenant du module typing en Python qui vous permet de créer un nouveau type qui n'est qu'un wrapper autour d'un type existant. Cela peut être utile pour ajouter plus de sens sémantique aux variables et aux arguments de fonction.

Voici un exemple :

Créez un projet appelé newtype.py dans WebIDE et entrez le contenu suivant.

Ensuite, exécutez le script Python suivant.

from typing import NewType

UserId = NewType("UserId", int)
OrderId = NewType("OrderId", int)

def get_order(order_id: OrderId) -> str:
    return f"Commande avec l'ID : {order_id}"

order_id = OrderId(123)
user_id = UserId(123)

print(get_order(order_id))  ## Sortie : Commande avec l'ID : 123

Utilisez la commande suivante pour exécuter le script.

python newtype.py

Contrôle de type statique

En Python, le contrôle de type statique peut être effectué à l'aide d'indicateurs de type et d'un vérificateur de type statique comme mypy. Les indicateurs de type indiquent les types attendus pour les variables, les arguments de fonction et les valeurs de retour. Voici un exemple :

Tout d'abord, installez mypy.

pip install mypy

Voici un exemple :

Créez un projet appelé mypy.py dans WebIDE et entrez le contenu suivant.

def add_numbers(x: int, y: int) -> int:
    return x + y

result = add_numbers(2, 3)
print(result)

Ensuite, exécutez mypy sur votre script.

mypy mypy.py

Cela vous donnera des informations sur tout inconvénient de type trouvé dans votre code.

Sommaire

C'est tout! Vous savez maintenant utiliser le module typing de Python pour ajouter des indicateurs de type à votre code. Les indicateurs de type peuvent améliorer considérablement la lisibilité et la maintenabilité du code, facilitant ainsi la manipulation de bases de code plus importantes et la collaboration avec d'autres personnes.