Python - Get Function Signature

Understanding function signatures in Python is essential for analyzing function parameters, data types, and default values. The inspect module provides powerful methods like signature() and getfullargspec() to retrieve detailed function information programmatically.

Using inspect.signature() Method

The inspect.signature() method provides comprehensive access to function parameter details including annotations, default values, and parameter kinds ?

Example

import inspect

def my_function(arg1: int, arg2: str = "default", *args: int, **kwargs: float) -> bool:
    pass

signature = inspect.signature(my_function)
params = signature.parameters

for name, param in params.items():
    print(f"Parameter: {name}")
    print(f"Type: {param.annotation}")
    print(f"Default Value: {param.default}")
    print(f"Kind: {param.kind}")
    print("---")

Parameter: arg1
Type: <class 'int'>
Default Value: <class 'inspect._empty'>
Kind: POSITIONAL_OR_KEYWORD
---
Parameter: arg2
Type: <class 'str'>
Default Value: default
Kind: POSITIONAL_OR_KEYWORD
---
Parameter: args
Type: <class 'int'>
Default Value: <class 'inspect._empty'>
Kind: VAR_POSITIONAL
---
Parameter: kwargs
Type: <class 'float'>
Default Value: <class 'inspect._empty'>
Kind: VAR_KEYWORD
---

Using inspect.getfullargspec() Method

The getfullargspec() function provides a structured approach to access function arguments, defaults, and annotations ?

Example

import inspect

def my_function(arg1: int, arg2: str = "hello", *args: tuple, **kwargs: dict) -> bool:
    pass

argspec = inspect.getfullargspec(my_function)

print(f"Arguments: {argspec.args}")
print(f"Defaults: {argspec.defaults}")
print(f"Annotations: {argspec.annotations}")
print(f"Varargs: {argspec.varargs}")
print(f"Keywords: {argspec.varkw}")

Arguments: ['arg1', 'arg2']
Defaults: ('hello',)
Annotations: {'arg1': <class 'int'>, 'arg2': <class 'str'>, 'args': <class 'tuple'>, 'kwargs': <class 'dict'>, 'return': <class 'bool'>}
Varargs: args
Keywords: kwargs

Practical Use Case

Here's how you can create a function documentation generator using function signatures ?

import inspect

def calculate_area(length: float, width: float = 1.0) -> float:
    """Calculate rectangle area."""
    return length * width

def document_function(func):
    sig = inspect.signature(func)
    print(f"Function: {func.__name__}")
    print(f"Signature: {sig}")
    print(f"Return type: {sig.return_annotation}")
    
    for name, param in sig.parameters.items():
        has_default = param.default != inspect.Parameter.empty
        default_info = f" (default: {param.default})" if has_default else ""
        print(f"  {name}: {param.annotation}{default_info}")

document_function(calculate_area)

Function: calculate_area
Signature: (length: float, width: float = 1.0) -> float
Return type: <class 'float'>
  length: <class 'float'>
  width: <class 'float'> (default: 1.0)

Comparison

Conclusion

The inspect module's signature() and getfullargspec() methods provide powerful ways to analyze function signatures programmatically. Use signature() for detailed parameter inspection and getfullargspec() for structured argument information.