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):
    func()

Answers:

Thank you for visiting the Q&A section on Magenaut. Please note that all the answers may not help you solve the issue immediately. So please treat them as advisements. If you found the post helpful (or not), leave a comment & I’ll get back to you as soon as possible.

Method 1

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]

Method 2

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

Method 3

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.

Method 4

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:
True

Method 5

In python3 it works without import typing:

def my_function(other_function: callable):
    pass

All methods was sourced from stackoverflow.com or stackexchange.com, is licensed under cc by-sa 2.5, cc by-sa 3.0 and cc by-sa 4.0