Wasim Thabraze

Typing module in Python

Tue, 21 Aug 2018 00:00:00 +0000

Declaring int, str, float variables is simple but declaring complex data types like List of tuples, List of dictionaries etc is cumbersome. This is where typing module comes to rescue.

The typing module in Python 3.6 contains many definitions that are useful in statically typed code.

Here’s how to use the typing module in Python 3:

from typing import Tuple, List, Dict

data: Tuple[int, str, List[int]] = (3, "Python" [1, 2, 3])
x: Dict[str, float]  = {'field': 2.0}

As generator function is also a function that returns an Iterable, here’s how to type annotate it :

from typing import Iterable
def f(n: int) -> Iterable[int]:
    i = 0
    while i < n:
        yield i
        i += 1

Below snippet uses the Union type which is used to specify that the address argument can either be a string or a list of strings and the type Optional is specified for values that could be None.

from typing import Union, Optional
def send_email(address: Union[str, List[str]],
               cc: Optional[List[str]
              ) -> bool: ...

Here’s how to type annotate Python 2 code using comments :

from typing import Tuple, List, Dict, Optional, Union, Iterable

data = (3, "Python" [1, 2, 3]) # type: Tuple[int, str, List[int]]
x = {'field': 2.0} # type: Dict[str, float]
def f(n: int):
    # type: (int) -> Iterable[int]
    i = 0
    while i < n:
        yield i
        i += 1
def send_email(address, # type: Union[str, List[str]],
               cc,      # type: Optional[List[str]
              ):
# type: (...) -> bool
...

Using Type aliases

Type aliases can be defined by using simple variable assignments. It’s generally used when the type gets lengthier. In below exampleExampleType can be referenced at all places where the variable data is used.

ExampleType = Tuple[int, str, List[int]]
data: ExampleType = (3, "Python" [1, 2, 3])

Creating your own types

In Python 3.5 a new function is introduced in typing called NewType. This allows you to create distinct types. The static type checker will treat the new type as if it were a subclass of the original type. You may still perform all int operations on a variable of type UserId, but the result will always be of type int.

from typing import NewType

UserId = NewType('UserId', int)
some_id = UserId(524313)

One of the best use cases of mypy is that it helps in self documenting code to an extent. Some of the large code bases can be tough to read. It’s difficult to tell what a function or a class accepts. Type hinting would help in adding clarity and readability to code.

Awesome folks at Dropbox built a Pycharm plugin that type checks and highlights the errors in the file.

For more information about mypy and typing I would recommend reading their official documentation. And for folks starting on type hinting their Python projects I would recommend reading this blog where Tim Abbott detailed how Zulip started with and implemented type hinting.

Mypy - Optional static typing for Python - Part 1

Mon, 23 Jul 2018 00:00:00 +0000

Mypy is an experimental static type checker for Python. As Python is a dynamically typed language, mypy aims to combine the benefits of dynamic typing and static typing.

In other words, mypy is like a linter that scans your code and prints out errors if there are any type conflicts.

Role of PEP-484

PEP-484 introduced the standard of type annotations (type hints) in Python. This standard came into existence from Python 3.5. This proposal adds syntax to Python for annotating the types of variables including class and instance variables.

If you’re using Python 3.5 or greater, you can write function definitions as shown below

def func(argv: Optional[Sequence[str]]) -> None: ...

In the above snippet, the term after : represents the type of the parameter and the term after -> represents the return type of the function.

With the addition of PEP-484, Python 3.5 gained two things:

A standard for describing types
A syntax support for annotating function arguments and the return values.

Now that we know about type annotations, but what exactly is type checking?

Inspection of code to enforce that arguments and assignments match their declared types is known as type checking.

Python 3.5 introduced type annotations but it didn’t come with built-in type checking. Core developers left the role to be filled by third party tools.

There are handful of tools that perform PEP-484 compatible type checking and mypy is one of them.

Annotation syntax for function declarations in Python 3 is as shown below

def plus(num1: int, num2: int) -> int:
    return num1 + num2

To check Python 3 code against mypy, run the command mypy program.py.

Since type annotations were introduced in Python 3, for code that needs to be Python 2.7 compatible, function type annotations are given in comments as shown below. This syntax is also valid in Python 3 mode.

def plus(num1, num2):
    # type: (int, int) -> int
    return num1 + num2

To check Python 2 code against mypy, run mypy in Python 2 mode using the — py2 option.

Using Mypy

When a script is run with a standard Python interpreter, the type annotations are treated primarily as comments. As mypy is a static analyzer, it does not cause any overhead when running the program.

Let’s take a look at a simple example:

def function(number: int, name: str) -> None:
	print("%s entered %s" % (name, number))

Above function takes in two parameters one of the type int and other of type str.

If we call the function as function(4, “John”) and run mypy, issuing the command mypy program.py, we get no errors or warnings. So the provided type annotations are correct.

However if we call the above function as function(“4", “John”) and run mypy, it throws an error saying error: Argument 1 to “function” has incompatible type “str”; expected “int”

Using mypy, common code bugs can be found and it checks the code for proper arguments and return types.

Remember that a function without a type annotation is considered dynamically typed.