Practical Guide to Python Static Typing

abstract_types_for_immutability1.py

from functools import lru_cache

@lru_cache(None)
def getvalue() -> List[Set[int]]:
    return [{1, 2}, {3}]

x = getvalue()
x.append({4})

y = getvalue()
x == y  # True! bad!
x is y  # True! bad!

abstract_types_for_immutability2.py

from functools import lru_cache

@lru_cache(None)
def getvalue() -> Sequence[AbstractSet[int]]:
    return [{1, 2}, {3}]

x = getvalue()
x.append({4})  # mypy errors: no append method
x[0].add(4)  # mypy errors: no add method

concrete_vs_abstract_args_results1.py

def get_unique(input: List[str], invalid: List[str]) -> List[str]:
    return [x for x in input if x not in invalid]

concrete_vs_abstract_args_results2.py

def get_unique(input: Iterable[str], invalid: Container[str]) -> List[str]:
    return [x for x in input if x not in invalid]
  

dont_obscure_is_none1.py

if None not in (x, y, z):
    result = x + y + z

dont_obscure_is_none2.py

if x is not None and y is not None and z is not None:
    result = x + y + z

dont_obscure_is_none3.py

inputs = (x, y, z)
valid = [v for v in inputs if v is not None]
if len(valid) == len(inputs):
    result = sum(valid)

dont_obscure_isinstance1.py

if inspect.isclass(x) and issubclass(x, Asset):
    ...

dont_obscure_isinstance2.py

if isinstance(x, type) and issubclass(x, Asset):
    ...

dont_obscure_isinstance3.py

isAsset = isinstance(x, Asset)
if isAsset:
    ...
else:
    ...

dont_obscure_isinstance4.py

if isinstance(x, Asset):
    isAsset = True
    ...
else:
    isAsset = False
    ...

relax_inferred_types1.py

import subprocess
from typing import *

def ls(env: Optional[Dict[str, str]] = None) -> None:
    args = "ls -la"
    kwargs = {"shell": True}  # <-- inferred type is Dict[str, bool] !!!
    if env:
        kwargs["env"] = env  # error! env is not a bool
    subprocess.call(args, **kwargs)

relax_inferred_types2.py

import subprocess
from typing import *

def ls(env: Optional[Dict[str, str]] = None) -> None:
    args = "ls -la"
    kwargs: Dict[str, Any] = {"shell": True}
    if env:
        kwargs["env"] = env
    subprocess.call(args, **kwargs)

relax_inferred_types3.py

if whatever:
    foo = 2
else:
    foo = 'some string'

relax_inferred_types4.py

if whatever:
    foo: Union[int, str] = 2
else:
    foo = 'some string'

reuse_variables_loops1.py

l1 = [v for k, v in d.items() if k.startswith('foo')]
kwargs = {k: v for k, v in kw.items() if k in _keys}

reuse_variables_loops2.py

for i, path in enumerate(paths):
    ...
for i, item in enumerate(items):  # ok!  i is still an int
    ...

reuse_variables_narrow_type1.py

import subprocess
from typing import *

def run(args: Union[str, List[str]], env: Optional[Dict[str, str]] = None) -> None:
    kwargs: Dict[str, Any] = {
        "shell": False,
    }
    if isinstance(args, str):
        # in this scope, args is understood to be a str 
        args = args.split()  # convert from str to List[str]. the str case of Union[str, List[str]] is now removed
    # at this point args can now only be List[str]
    if env:
        kwargs["env"] = env
    subprocess.call(args, **kwargs)

reuse_variables_new_variable1.py

import subprocess
from typing import *

def run(args: str, env: Optional[Dict[str, str]] = None) -> None:
    kwargs: Dict[str, Any] = {
        "shell": False,
    }
    args = args.split()  # can't reassign the type of args!
    args.insert(0, 'xdg-open')
    if env:
        kwargs["env"] = env
    subprocess.call(args, **kwargs)

reuse_variables_new_variable2.py

import subprocess
from typing import *

def run(command: str, env: Optional[Dict[str, str]] = None) -> None:
    kwargs: Dict[str, Any] = {
        "shell": False,
    }
    args = command.split()
    args.insert(0, 'xdg-open')
    if env:
        kwargs["env"] = env
    subprocess.call(args, **kwargs)

reuse_variables_return_early1.py

def letter_list(s: str, strip_last: bool = False) -> Optional[str]:
    if s:
        result = list(s)
        if strip_last:
            result = result[:-1]
    else:
        result = None   # <--- error: incompatible type
    return result

reuse_variables_return_early2.py

def letter_list(s: str, strip_last: bool = False) -> Optional[str]:
    if s:
        result: Optional[str] = list(s)
        if strip_last:
            result = result[:-1]   # <--- error: None does not support indexing
    else:
        result = None
    return result

reuse_variables_return_early3.py

def letter_list(s: str, strip_last: bool = False) -> Optional[str]:
    if s:
        result = list(s)
        if strip_last:
            result = result[:-1]
        return result
    else:
        return None

tuple_types1.py

class Base:
    validThings = ('thing1',)

class A(Base):
    validThings = ('thing1', 'thing2')

tuple_types2.py

class Base:
    validThings: Tuple[str, ...] = ('thing1',)

class A(Base):
    validThings: Tuple[str, ...] = ('thing1', 'thing2')

tuple_types3.py

class Base:
    validThings = FrozenSet(['thing1'])

class A(Base):
    validThings = FrozenSet(['thing1', 'thing2'])

tuple_types4.py

class Base:
    validThings: Final[List[str]] = ['thing1']

class A(Base):
    validThings: Final[List[str]] = ['thing1', 'thing2']