Annotations

En python il est possible de faire des annotations:

def addition(a: int, b: int) -> int:
    return a + b

Le module typing présente une collection de classes pour composer des types. Ce module a été introduit dans Python 3.5, et n’est donc pas disponible dans les versions précédentes du langage.

Dans notre fonction addition, nous voudrions en fait que les int, float et complex soient admis. Nous pouvons pour cela utiliser le type Union du module typing :

from typing import Union
 
Number = Union[int, float, complex]
 
def addition(a: Number, b: Number) -> Number:
    return a + b

Nous utilisons ici Union mais il en existe d'autres comme par exemple :

List[str] : Une liste de chaînes de caractères ;
Sequence[str] : Une séquence (liste/tuple/etc.) de chaînes de caractères ;
Callable[[str, int], str] : Un callable prenant deux paramètres de types str et int respectivement, et retournant un objet str

def foo(arg: Optional[int] = None) -> None:
    ...

def foo(arg: Optional[List[Union[int, str]]] = None) -> None:
    ...

max_value : int = 10 # Définition d'une variable max_value annotée comme int
min_value : int      # Annotation seule, la variable n'est pas définie dans ce cas

from typing import List
Vector = List[float]
 
def scale(scalar: float, vector: Vector) -> Vector:
    return [scalar * num for num in vector]

from typing import Dict, Tuple, Sequence
 
ConnectionOptions = Dict[str, str]
Address = Tuple[str, int]
Server = Tuple[Address, ConnectionOptions]
 
def broadcast_message(message: str, servers: Sequence[Server]) -> None:
    ...
 
# The static type checker will treat the previous type signature as
# being exactly equivalent to this one.
def broadcast_message(
        message: str,
        servers: Sequence[Tuple[Tuple[str, int], Dict[str, str]]]) -> None:
    ...

from typing import Callable
 
def feeder(get_next_item: Callable[[], str]) -> None:
    # Body
 
def async_query(on_success: Callable[[int], None],
                on_error: Callable[[int, Exception], None]) -> None:
    # Body

from typing import Any
     # OK
 
def foo(item: Any) -> int:
    ...

T = TypeVar('T')  # Can be anything
A = TypeVar('A', str, bytes)  # Must be str or bytes
 
def repeat(x: T, n: int) -> Sequence[T]:
    """Return a list containing n references to x."""
    return [x]*n
 
def longest(x: A, y: A) -> A:
    """Return the longest of two strings."""
    return x if len(x) >= len(y) else y

def fib(n: int) -> Iterator[int]:
    a, b = 0, 1
    while a < n:
        yield a
        a, b = b, a+b