CODEWITHSUNDEEP
pythonmypypython-typing
Jon
Jon

Reputation: 12864

How can I specify the function type in my type hints?

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.

Upvotes: 652

Views: 395845

Answers (3)

Dimitris Fasarakis Hilliard
Dimitris Fasarakis Hilliard

Reputation: 160367

As @jonrsharpe noted in a comment, this can be done with collections.abc.Callable:

from collections.abc import Callable

def my_function(func: Callable):

Note: Callable on its own is equivalent to Callable[..., Any]. Such a Callable 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:

def sum(a: int, b: int) -> int: return a+b

The corresponding annotation is:

Callable[[int, int], int]

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:

Callable[[ParamType1, ParamType2, ..., ParamTypeN], ReturnType]

Upvotes: 937

John Carrell
John Carrell

Reputation: 1970

My specific use case for wanting this functionality was to enable rich code completion in PyCharm. Using Callable didn't cause PyCharm to suggest that the object had a .__code__ attribute, which is what I wanted, in this case.

I stumbled across the types module and..

from types import FunctionType

allowed me to annotate an object with FunctionType and, voilà, PyCharm now suggests my object has a .__code__ attribute.

The OP wasn't clear on why this type hint was useful to them. Callable certainly works for anything that implements .__call__() but for further interface clarification, I submit the types module.

Bummer that Python needed two very similar modules.

Upvotes: 23

Hallsville3
Hallsville3

Reputation: 511

Another interesting point to note is that you can use the built in function type() to get the type of a built in function and use that. So you could have

def f(my_function: type(abs)) -> int:
    return my_function(100)

Or something of that form

Upvotes: 20

Related Questions