How can I specify the type hint of a variable as a function type? There is no typing.Function
, and I could not find anything in the relevant PEP, PEP 483.
Python – How to Specify Function Type in Type Hints
mypypythonpython-3.xpython-typingtype-hinting
Related Solutions
You can use a global variable within other functions by declaring it as global
within each function that assigns a value to it:
globvar = 0
def set_globvar_to_one():
global globvar # Needed to modify global copy of globvar
globvar = 1
def print_globvar():
print(globvar) # No need for global declaration to read value of globvar
set_globvar_to_one()
print_globvar() # Prints 1
Since it's unclear whether globvar = 1
is creating a local variable or changing a global variable, Python defaults to creating a local variable, and makes you explicitly choose the other behavior with the global
keyword.
See other answers if you want to share a global variable across modules.
TL;DR: As of today (2019), in Python 3.7+ you can turn this feature on using a "future" statement, from __future__ import annotations
.
(The behaviour enabled by from __future__ import annotations
might become the default in future versions of Python, and was going to be made the default in Python 3.10. However, the change in 3.10 was reverted at the last minute, and now may not happen at all. Python 3.11 does not include it)
In Python 3.6 or below, you should use a string.
I guess you got this exception:
NameError: name 'Position' is not defined
This is because Position
must be defined before you can use it in an annotation, unless you are using Python with PEP 563 changes enabled.
Python 3.11+: from typing import Self
from typing import Self
class Position:
def __add__(self, other: Self) -> Self:
...
For Python versions < 3.11, you can use:
from typing_extensions import Self
References:
- https://docs.python.org/3/whatsnew/3.11.html#pep-673-self-type
- https://docs.python.org/3/library/typing.html#typing.Self
- https://realpython.com/python-type-self/
Python 3.7+: from __future__ import annotations
Python 3.7 introduces PEP 563: postponed evaluation of annotations. A module that uses the future statement from __future__ import annotations
will store annotations as strings automatically:
from __future__ import annotations
class Position:
def __add__(self, other: Position) -> Position:
...
This had been scheduled to become the default in Python 3.10, but this change has now been postponed. Since Python still is a dynamically typed language so no type-checking is done at runtime, typing annotations should have no performance impact, right? Wrong! Before Python 3.7, the typing module used to be one of the slowest python modules in core so for code that involves importing the typing
module, you will see an up to 7 times increase in performance when you upgrade to 3.7.
Python <3.7: use a string
According to PEP 484, you should use a string instead of the class itself:
class Position:
...
def __add__(self, other: 'Position') -> 'Position':
...
If you use the Django framework, this may be familiar, as Django models also use strings for forward references (foreign key definitions where the foreign model is self
or is not declared yet). This should work with Pycharm and other tools.
Sources
The relevant parts of PEP 484 and PEP 563, to spare you the trip:
Forward references
When a type hint contains names that have not been defined yet, that definition may be expressed as a string literal, to be resolved later.
A situation where this occurs commonly is the definition of a container class, where the class being defined occurs in the signature of some of the methods. For example, the following code (the start of a simple binary tree implementation) does not work:
class Tree: def __init__(self, left: Tree, right: Tree): self.left = left self.right = right
To address this, we write:
class Tree: def __init__(self, left: 'Tree', right: 'Tree'): self.left = left self.right = right
The string literal should contain a valid Python expression (i.e., compile(lit, '', 'eval') should be a valid code object) and it should evaluate without errors once the module has been fully loaded. The local and global namespace in which it is evaluated should be the same namespaces in which default arguments to the same function would be evaluated.
and PEP 563:
Implementation
In Python 3.10, function and variable annotations will no longer be evaluated at definition time. Instead, a string form will be preserved in the respective
__annotations__
dictionary. Static type checkers will see no difference in behavior, whereas tools using annotations at runtime will have to perform postponed evaluation....
Enabling the future behavior in Python 3.7
The functionality described above can be enabled starting from Python 3.7 using the following special import:
from __future__ import annotations
Things that you may be tempted to do instead
A. Define a dummy Position
Before the class definition, place a dummy definition:
class Position(object):
pass
class Position(object):
...
This will get rid of the NameError
and may even look OK:
>>> Position.__add__.__annotations__
{'other': __main__.Position, 'return': __main__.Position}
But is it?
>>> for k, v in Position.__add__.__annotations__.items():
... print(k, 'is Position:', v is Position)
return is Position: False
other is Position: False
B. Monkey-patch in order to add the annotations:
You may want to try some Python metaprogramming magic and write a decorator to monkey-patch the class definition in order to add annotations:
class Position:
...
def __add__(self, other):
return self.__class__(self.x + other.x, self.y + other.y)
The decorator should be responsible for the equivalent of this:
Position.__add__.__annotations__['return'] = Position
Position.__add__.__annotations__['other'] = Position
At least it seems right:
>>> for k, v in Position.__add__.__annotations__.items():
... print(k, 'is Position:', v is Position)
return is Position: True
other is Position: True
Probably too much trouble.
Related Question
- Python Performance – Why ‘1000000000000000 in range(1000000000000001)’ is So Fast in Python 3
- Python Type Hints – How to Specify Multiple Return Types
- Python Dictionary Sorting – How to Sort by Value
- Python – How Slicing in Python Works
- How to Pass a Variable by Reference in Python
- Python – Canonical Way to Check for Type
- Python – How to Check if a String is Empty
- Python – How to Specify ‘Nullable’ Return Type with Type Hints
Best Answer
As @jonrsharpe noted in a comment, this can be done with
typing.Callable
:Note:
Callable
on its own is equivalent toCallable[..., Any]
. Such aCallable
takes any number and type of arguments (...
) and returns a value of any type (Any
). If this is too unconstrained, one may also specify the types of the input argument list and return type.For example, given:
The corresponding annotation is:
That is, the parameters are sub-scripted in the outer subscription with the return type as the second element in the outer subscription. In general: