Try type hints

Overview

PEP 484: Type Hints was introduced in Python 3.5. For more information, see Official document type hint support (https://docs.python.org/en/3/library/typing.html).

Recently, I've heard a lot of stories that have been introduced in the community. I would like to introduce it in future projects as well, and I will summarize it here for reference when studying myself and explaining it to others.

Type hints were introduced in Python 3.5 and later as a Python grammar.

--Since it is a hint, it has no effect at runtime --There is no official built-in tool

tool

--There is a de facto check tool called mypy (installable with pip) ――Editors such as PyCharm support it, code interpolation becomes powerful, and it also checks. --Valid only in the place where the hint is described (either module or function) ――The more hints you write, the more effective the code interpolation will be, and the more it will check.

mypy cheat sheet

install mypy

(env) $ pip install mypy

Check with mypy

(env) $mypy module name

Type hint definition example

As an example, all are shown as integer (int) type.

Variable definition


a: int = 10
a: int
a = 10

Function argument definition

def f(a: int):
    pass

def f(a: int = 10):
    pass

Function return value definition


def f(a) -> int:
    return 10

def f(a: int, b: int = 10) -> int:
    return a + b

Type definition

Defined by data type

name Mold
integer int
Floating point number float
String str
Byte type bytes
Truth value bool
None None

Container system

Since the container system specifies the type to be included, I want to write it as list [int]. However, this results in a Python syntax error. For that reason, typing prepares a dedicated mold.


from typing import List, Tuple, Dict, Set
name Mold Definition example
list List List[int]
Tuple Tuple Tuple[int, int] / Tuple[int, ...]
dictionary Dict Dict[str, int]
set Set Set[int]

Special type

from typing import Any
name Mold Definition example
Anything is fine Any Any

from typing import Callable, Iterator, MutableMapping
name Mold Definition example
Callable Callable Callable[[int, float], bool]
Repeatable Iterator Iterator[int]
Behavior like a dictionary MutableMapping MutableMapping[str, int]

Other

Optional

Optional is a type that allows the specified type or None. For example, ʻOptional [int]` to allow either an integer or None.

It is used in the following cases.


from typing import Optional

def f1(a: int, b: int) -> Optional[int]:
    if b == 0:
        return None
    return a // b

It is convenient because it can be used as follows.


def f2(c: Optional[int]) -> int:
    if c is None:
        c = 0
    return c + 100

If you describe the above case as follows, mypy will notify you of the error.


def f2(c: Optional[int]) -> int:
    return c + 100
$ mypy sample.py 
sample.py:**: error: Unsupported operand types for + ("None" and "int")
sample.py:**: note: Left operand is of type "Optional[int]"
Found 1 error in 1 file (checked 1 source file)

That is, by doing ʻif c is None`, we add the time when c is None, so that in the subsequent lines, the variable c Is determined to be an integer type (int), so we guarantee that it can be processed without problems.

Union

Union can indicate one of two types. For example, when you say integer type or string type, specify ʻUnion [int, str]`.

When receiving an argument as shown below, it is used when you do not know whether it is an integer or a character string, and by dividing the process using ʻisinstance`, you can determine the variable type in the same way as Optional above. I can do it.


from typing import Union

def f3(d: Union[int, str]) -> str:
    if not isinstance(d, str):
        d = str(d)
    return d.upper()

Here, as ʻif not is instance (d, str):, when the variable d is not a character string type (str), the process of converting to a character string is inserted and the process is continued. Since return d.upper () knows that d` is a string, we can use a string-type method to safely convert it to uppercase.

int and float

You cannot specify a float by specifying int, but you can specify an opposite float and insert an int. In the following cases, only num4 will give an error.


num1: float = 1.0
num2: float = 1
num3: int = 1
num4: int = 1.0  #This will result in an error
$ mypy sample/sample.py 
sample.py:**: error: Incompatible types in assignment (expression has type "float", variable has type "int")

It seems that this is because int can be automatically converted to float, but if the opposite float is set to int, information may be lost.

Recommended Posts

Try type hints
[Translation] PEP 0484 --Type Hints
Practice! !! Introduction to Python (Type Hints)
Increase source visibility with type hints
Shell type
Dictionary type 2
Dictionary type 1
try pysdl2
Try PyOpenGL
Want to add type hints to your Python decorator?