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? (See also: PEP 483.)

import typing

def my_function(func: typing.Function):
Asked By: Jon



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

from typing 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]

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

Answered By: Hallsville3

An easiest and fancy solution is:

def f(my_function: type(lambda x: None)):
    return my_function()

This can be proved in the following way:

def poww(num1, num2):
    return num1**num2
print(type(lambda x: None) == type(poww))

and the output will be:

Answered By: Jorge Massih

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.

Answered By: John Carrell

In python3 it works without import typing:

def my_function(other_function: callable):
Answered By: Jack Scandall