I previously covered type narrowing using isinstance(), assert, and Literal.
In today’s post we’ll cover TypeGuard, a new special type that allows us to create custom type narrowing functions.
Sometimes the types of several variables are related, such as “if x is type A, y is type B, else y is type C”.
Basic type hints cannot describe such relationships, making type checking cumbersome or inaccurate.
We can instead use @typing.overload to represent type relationships properly.
It seems inevitable that large projects need some # type: ignore comments, to work around type checking in tricky cases.
I’ve found Mypy has a couple of opt-in flags to make such ignore comments more precise and manageable.
Mypy does not allow variables to change type. I found this a little bit of a shock at first, but after I adapted, I found my code was more readable.
Read more...
A couple of recent PEP’s have made writing type hints easier:
Read more...
Sometimes functions never return, for example by always raising an exception.
For such functions’ return types, we can “get away” with using None, but it’s best to use the special NoReturn type).
This allows Mypy to better find unreachable code (as covered previously).
It also shows future readers that the lack of return is intentional.
I recently discovered Mypy has a secondary function as an unreachable code detector. This feature is a great way to highlight places bugs may be hiding, as code paths that can’t possibly run normally show a logical error.
Read more...
Duck typing says “if it quacks like a duck, treat it like a duck.”
Type checking seems at odds with duck typing: we restrict variables to named types (classes), allowing only that type or subtypes.
This seems like it would stop us from passing in arbitrary objects that can “quack the right way”.
But since PEP 0544, we can declare “duckish” types with typing.Protocol.
Type narrowing is the ability for a type checker to infer that inside some branch, a variable has a more specific (narrower) type than its definition. This allows us to perform type-specific operations without any explicit casting.
Read more...
In a type hint, if we specify a type (class), then we mark the variable as containing an instance of that type.
To specify that a variable instead contains a type, we need to use type[Cls] (or the old syntax typing.Type).