Python：重载实例方法和 Class 方法/从 Class 方法访问实例变量

Question

I was wondering what the best way to implement the following design would be in Python:

class Executor:
    def __init__(self):
        self.val = 5

    def action(self):
        self.action(self.val)

    @classmethod
    def action(cls, val):
        print(f"Val is: {val}")

I want to be able to access the method both as an instance method that uses the value the object was initialised with, and as a class method which uses a passed in variable. Here is an example of the ways in which I would like to call it:

>>> Executor.action(3)
Val is: 3
>>> Executor().action()
Traceback (most recent call last):
  File "<input>", line 1, in <module>
TypeError: action() missing 1 required positional argument: 'val'

I was thinking about trying to use keyword arguments, but I can't seem to get that to work either. Here is my code so far:

class Executor:
    def __init__(self):
        self.val = 5

    @classmethod
    def action(cls, val=None):
        if val is None:
            # This doesn't work; cls does not have attribute 'val'.
            if hasattr(cls, "val"):
                print(f"Val from instance: {cls.val}")

            else:
                raise ValueError("Called as class method and val not passed in.")

        else:
            print(f"Val passed in: {val}")


>>> Executor.action(3)
Val passed in: 3
>>> Executor().action()
Traceback (most recent call last):
  File "<input>", line 1, in <module>
  File "<input>", line 13, in action
ValueError: Called as class method and val not passed in.

But the class instance does not have the val available for access.

The only other thing I can think of is using Hungarian notation, but it's not ideal as it's a bit messy, and it means there's multiple method names.

class Executor:
    def __init__(self):
        self.val = 5

    def action_instance(self):
        self.action_class(self.val)

    @classmethod
    def action_class(cls, val):
        print(f"Val is: {val}")


>>> Executor.action_class(3)
Val is: 3
>>> Executor().action_instance()
Val is: 5

Any advice on a solid, clean approach would be greatly appreciated!

Cheers.

Answer 1

What you want to do looks strange to me, I am not sure you need that. Python cannot overload by method signatures/type, although there is the functools.singledispatch . So by defining action a second time you are actually replacing the first definition for the method.

The observable behaviour can be achieved with:

class Executor:

    @classmethod
    def action(cls, val=5):
        return val

print(Executor().action())
print(Executor.action(3))

Outputs:

5
3

But again check first that you really need something like that, because it breaks one of the expectations of Python coders and Python data model: calling a method through the class is equivalent to calling the method through the instance given that you pass the instance to the class method.

obj = Executor()
obj.action() # this is the same as Executor.action(obj)