Ceci est une ancienne révision du document !

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 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 </code> <code python> from typing import List Vector = List[float] def scale(scalar: float, vector: Vector) -> Vector: return [scalar * num for num in vector] </code> <code python> 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:

… </code>

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