Python：避免同时定义classmethod和instancemethod

Question

NOTE on the question below. I think the 'proper' pythonic idiom is to a) create module functions, such as foo_math below, and then call their specific action against an instance within the class itself. The bottom piece of code reflects that approach.

---

I want to define a classmethod which takes two arguments and returns a value. I want the same method to be able to be called on a class instance with the instance value pass as one of the arguments. Can I do this without defining two distinct methods as I have done here?

class Foo(object):
    __init__(x):
        self.x = x

    @classmethod
    def foo_math(cls, x, y):
         return x + y

    def math(self, y):
        return Foo.foo_math(self.x, y)

What I would like is:

>>> Foo.math(3, 4)
7
>>> f = Foo()
>>> f.x = 3
>>> f.math(4)
7

Short of subtyping int , here is my conclusion to this question:

def foo_math(cls, x, y):
     return x + y

class Foo(object):
    __init__(x):
        self.x = x

    def foo_math(self, y):
        return foo_math(self, y)

Answer 1

I don't think that you can call a method from a class without defining an object of that class (class methods don't belong inside the methods of any one class), so things like Foo.math(3, 4) will return a NameError as Foo has not been defined.

With this in mind, you should modify your code to be like this (even though with the problem solved there are still some issues with the code):

# A class method would probably go here somewhere.

class Foo(object):
    def __init__(self, x):
        self.x = x

    def foo_math(self, x, y):
         return x + y

    def math(self, y):
        return self.foo_math(self.x, y)

Then you can do:

>>> f = Foo(3)
>>> f.math(4)
7

Answer 2

i don't recommend doing this, but if you really want, it's this (thank you other guy on stackoverflow for first part):

class staticorinstancemethod(object):
    def __init__(self, func):
        self.func = func

    def __get__(self, instance, owner):
        return functools.partial(self.func, instance)

then, do something like

class F(object):
    @staticorinstancemethod
    def math(instOrNone, v1, v2=None):
        return instOrNone.x + v1 if instOrNone else v1 + v2

but maybe you just want to define the __add__ and __radd__ methods...