Python Type Annotations

The basic syntax for annotating a variable is to add a colon after the variable name, followed by the type of the variable. For example, the following code declares a variable x of type int:

x: int

From that point on it gets more complicated. For example, the following code declares a variable y of type List[int]:

y: List[int]

The type List[int] is a type annotation for a list of integers. The type List is a generic type, which means that it can be parameterized with a type. In this case, the type List is parameterized with the type int. The type List[int] is an instance of the generic List[T], where T is a type variable that can be replaced with any type. In this case, T is replaced with int.

To make a list of lists of integers, you can use the type List[List[int]]. To make a list of lists of lists of integers, you can use the type List[List[List[int]]]. And so on.

The type List is defined in the typing module, which is part of the Python standard library. The module also defines typing constructs such as Dict, Set, Tuple, Optional, Union, Callable, Iterable, Iterator, Sequence, Mapping, Any, TypeVar, and Generic. We introduce the ones we need when they first appear.

Now, let’s consider a function that takes two integers and returns their sum:

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

The type annotation -> int indicates that the function returns an integer. The type annotation int indicates that the function takes two integers as arguments. The type annotation x: int indicates that the variable x is of type int. The type annotation y: int indicates that the variable y is of type int.

Now consider a higher-order function that takes a function as an argument:

def twice(f: Callable[[int], int], x: int) -> int:
    return f(f(x))

The type annotation f: Callable[[int], int] indicates that the variable f is of type Callable[[int], int]. The type Callable[[int], int] is a generic type that is parameterized with two types: the type of the function’s arguments and the type of the function’s return value. In this case, the type Callable[[int], int] is parameterized with the type int for both the arguments and the return value. This means that the function f takes an integer as an argument and returns an integer.