Functions like this are called void, and they return None, Python's special object for "nothing". Also a simple return is equivalent to return None if you want to do it in the middle of function.
NoReturn means that the function doesn't give anything back to the caller, including the top of the call stack. If there weren't exception handling, it would be like an infinite loop because the interpreter would never leave the function's stack frame.
Type annotations — also known as type signatures — are used to indicate the datatypes of variables and input/outputs of functions and methods. In many languages, datatypes are explicitly stated. In these languages, if you don't declare your datatype — the code will not run.
It is a type variable. Type variables exist primarily for the benefit of static type checkers. They serve as the parameters for generic types as well as for generic function definitions.
This is straight from PEP 484 -- Type Hints documentation:
When used in a type hint, the expression
None
is considered equivalent totype(None)
.
And, as you can see most of the examples use None
as return type.
TLDR: The idiomatic equivalent of a void
return type annotation is -> None
.
def foo() -> None:
...
This matches that a function without return
or just a bare return
evaluates to None
.
def void_func(): # unannotated void function
pass
print(void_func()) # None
Omitting the return type does not mean that there is no return value. As per PEP 484:
For a checked function, the default annotation for arguments and for the return type is
Any
.
This means the value is considered dynamically typed and statically supports any operation. That is practically the opposite meaning of void
.
Type-hinting in Python does not strictly require actual types. For example, annotations may use strings of type names: Union[str, int]
, Union[str, 'int']
, 'Union[str, int]'
and various variants are equivalent.
Similarly, the type annotation None
is considered to mean "is of NoneType
". This can be used in other situations as well as return types, though you will see it most often as a return-type annotation:
bar : None
def foo(baz: None) -> None:
return None
This also applies to generic types. For example, you can use None
in Generator[int, None, None]
to indicate a generator does not take or return values.
Even though PEP 484 suggests that None
means type(None)
, you should not use the latter form explicitly. The type-hinting specification does not include any form of type(...)
. This is technically a runtime expression, and its support is entirely up to the type checker. The mypy project is considering whether to remove support for type(None)
and remove it from 484 as well.
Or maybe we should update PEP 484 to not suggest that
type(None)
is valid as a type, andNone
is the only correct spelling? There should one -- and preferably only one -- obvious way to do it etc.--- JukkaL, 18 May 2018
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With