To annotate the expected signature of a callable (function, method, or callable object) for static type checking and documentation.

Communicates the exact input and output types expected from a callable to type checkers and human readers.

When declaring a parameter, variable, or return type that must be a callable accepting an int and a str and returning a bool, such as event handlers, callbacks, or factory functions.

Used in Python type annotations, typically imported from typing (e.g., from typing import Callable) and placed in function signatures, variable annotations, or return type annotations.

Callable[[<arg1_type>, <arg2_type>], <return_type>] (specific: Callable[[int, str], bool])

Callable[[<Arg1>, <Arg2>], <Return>] where Arg1=int, Arg2=str, Return=bool.

arg1: type (int), arg2: type (str), return: type (bool)

• typing.Callable
• callback functions
• event handlers
• key functions for sorting
• factory functions
• Protocol definitions

• Callable[[int]
• bool] – single argument
• less specific
• Callable[[str]
• bool] – different argument type
• Callable[[]
• bool] – no arguments
• used for predicates
• Callable[[int
• str
• float]
• bool] – extra argument
• Callable[[int
• str]
• int] – different return type
• using ParamSpec for generic callables – more flexible but more complex.

1. Forgetting to import Callable from typing – causes NameError; 2. Omitting the return type (Callable[[int, str]]) – results in an overly generic Callable, losing return‑type safety; 3. Swapping argument order (Callable[[str, int], bool]) – leads to type‑checker flagging mismatched arguments; 4. Using the built‑in callable() instead of typing.Callable – loses ability to specify argument/return types; 5. Misplacing brackets (Callable[[int, str]] -> bool) – syntax error.

Callable[[int], bool] – callable with a single int argument; Callable[[], bool] – callable with no arguments; Protocol with __call__ method – defines a callable interface via structural subtyping; plain Callable – unspecified signature, less precise.

Coming from Java: may treat Callable like Java’s FunctionalInterface and forget to import typing.Callable, causing NameError → import typing.Callable and specify argument types; Coming from JavaScript: may expect dynamic callables and omit type annotations, resulting in weaker static checking → add explicit Callable[[int, str], bool] annotations for better tooling.

• type annotations
• callable types
• typing module

Do not use when the callable’s signature is unknown or varies dynamically, as over‑specifying can cause false positives; runtime impact is negligible because type hints are erased, though static analysis may incur minor overhead; a callable matching the signature via __call__ on an instance is compatible, whereas a C‑extension function with the same signature may fail certain isinstance checks.

Enables static type checkers to catch mismatched callbacks early, improves IDE autocomplete and refactoring safety, and documents expected callback contracts for maintainability.

Think of a Callable type hint as a ticket booth that only lets through passengers holding a ticket with an integer ID and a string name, guaranteeing they’ll either be admitted (True) or turned away (False).

From Python 3.9+ collections.abc.Callable can be used; from Python 3.10 the built‑in collection types support subscripting but Callable still requires typing or collections.abc.

Learn to use ParamSpec and Concatenate for generic higher‑order functions that preserve callable signatures.