Python中是否有“Addable”协议或抽象基class？ 如果不是，人们将如何定义它？

Question

The typing module contains many protocols and abstract base classes that formally specify protocols which are informally described in the data model , so they can be used for type hints.

However I was unable to find such a protocol or abstract base class for objects that support __add__ . Is there any formal specification of such a protocol? If not how would such an implementation look like?

Update:

Since I'm interested in such a class for the purpose of typing, such a class would only be useful if it's fully type itself, like the examples in the typing module.

Answer 1

To my knowledge there is no pre-defined Addable protocol. You can definie one yourself:

from typing import Protocol, TypeVar


T = TypeVar("T")


class Addable(Protocol):
    def __add__(self: T, other: T) -> T: ...

This protocol requires that both summands and the result share a common ancestor type.

The protocol can then be used as follows:

Tadd = TypeVar("Tadd", bound=Addable)


def my_sum(*args: Tadd, acc: Tadd) -> Tadd:
    res = acc
    for value in args:
        res += value

    return res


my_sum("a", "b", "c", acc="") # correct, returns string "abc"
my_sum(1, 2, 6, acc=0) # correct, returns int 9
my_sum(1, 2.0, 6, acc=0) # correct, returns float 9.0
my_sum(True, False, False, acc=False) # correct, returns bool 1 (mypy reveal_type returns bool, running it in python leads to result 1)

my_sum(True, False, 1, acc=1.0) # incorrect IMHO, but not detected by mypy, returns float 3.0

my_sum(1, 2, 6, acc="") # incorrect, detected by mypy
my_sum(1, 2, "6", acc=0) # incorrect, detected by mypy

Answer 2

You could define one yourself using the abc module . The ABC metaclass that is provided there allows you to define a __subclasshook__ , in which you can check for class methods such as __add__ . If this method is defined for a certain class, it is then considered a subclass of that abc.

from abc import ABC

class Addable(ABC):
    @classmethod
    def __subclasshook__(cls, C):
        if cls is Addable:
            if any("__add__" in B.__dict__ for B in C.__mro__):
                return True
        return NotImplemented

class Adder():
    def __init__(self, x):
        self.x = x
    def __add__(self, x):
        return x + self.x

inst = Adder(5)

# >>> isinstance(inst, Addable)
# True
# >>> issubclass(Adder, Addable)
# True

Answer 3

There exists such a protocol. Just not in the code that's usually executed... There exists a special package called typeshed that's used by type-checkers to add type-hints to code that isn't implemented with any type-hints... The typeshed package doesn't exist during runtime though.

So you can use _typeshed.SupportsAdd during type-checking - but to check during execution you'd need to check for the __add__ method dynamically or you implement the SupportsAdd protocol yourself...

from typing import TYPE_CHECKING
if TYPE_CHECKING:
    from _typeshed import SupportsAdd


# SupportsAdd must always be written in quotation marks when used later...
def require_adding_str_results_in_int(a_obj: "SupportsAdd[str, int]"):
    # the type checker guarantees that this should work now
    assert type(a_obj + "a str") == int

    # to check during runtime though you'd probably use
    assert hasattr(a_obj, "__add__")

Hope that helped... Most likely it's the best way to implement your own protocol and use the @runtime_checkable decorator. You can look at the source code of typeshed to get inspirations.