singledispatch

4.1.2 · active · verified Sat Apr 11

The `singledispatch` library provides a standalone implementation of the `functools.singledispatch` decorator, which allows for generic functions to have different behaviors based on the type of their first argument. Originally a backport for older Python versions, the PyPI package currently targets Python 3.9+ and is actively maintained with regular releases, as evidenced by recent version updates.

Warnings

gotcha Potential confusion with `functools.singledispatch` which is part of Python's standard library since Python 3.4. If you are using Python 3.4 or newer, `functools.singledispatch` is generally preferred unless you specifically need the `singledispatch` package's independent implementation or its associated utilities.
Fix: For new projects on Python 3.4+, consider using `from functools import singledispatch`. If you specifically need this package, ensure you import from `singledispatch`.
breaking Version 4.0.0 dropped support for Python 3.8, now requiring Python 3.9 or later. This is a significant breaking change for environments still using Python 3.8.
Fix: Upgrade your Python environment to 3.9+ or pin `singledispatch` to a version older than 4.0.0 (e.g., `~=3.7`) if you need to support Python 3.8.
gotcha The `singledispatch` decorator, by its nature, dispatches solely based on the *type of the first argument*. It does not support multiple dispatch (dispatching on multiple arguments) or dispatching based on keyword arguments.
Fix: If you require dispatching on multiple arguments or keyword arguments, you will need to implement a custom solution or use a third-party library designed for multiple dispatch.

Install

pip install singledispatch Install latest version

Imports

singledispatch
```
from singledispatch import singledispatch
```
While `functools.singledispatch` is built into Python 3.4+, this package provides a standalone implementation. If you install and use the `singledispatch` package, you should import from it directly to ensure you are using its version.
singledispatchmethod
```
from singledispatch import singledispatchmethod
```
`singledispatchmethod` was added to `functools` in Python 3.8. If targeting Python versions prior to 3.8 (though the `singledispatch` package itself now requires Python 3.9+), or if using this package's specific implementation, import from `singledispatch` directly.

Quickstart

This example demonstrates how to create a single-dispatch generic function using the `@singledispatch` decorator. It defines a default implementation and then registers specific implementations for `int` and `list` types. When called, the appropriate function is dispatched based on the type of the first argument.

from singledispatch import singledispatch

@singledispatch
def process_data(arg):
    """Default implementation for process_data"""
    return f"Processing generic data: {arg}"

@process_data.register(int)
def _(arg):
    """Process integer data"""
    return f"Processing integer: {arg * 2}"

@process_data.register(list)
def _(arg):
    """Process list data"""
    return f"Processing list: {', '.join(map(str, arg))}"

print(process_data("hello"))
print(process_data(10))
print(process_data([1, 2, 3]))
print(process_data(3.14))

view raw JSON →