Как реализовать подметод в классе Python?

Question

Приносим извинения, если я не выражаю свое ясное понимание. То, что я хочу сделать это:

class someClass(object): 
    def aMethod(self, argument): 
     return some_data #for example a list or a more complex datastructure 
    def aMethod_max(self, argument): 
     var = self.aMethod(argument) 
     #do someting with var 
     return altered_var  

или я мог бы сделать:

def aMethod(self, argument): 
     self.someVar = some_data 
     return some_data #for example a list or a more complex datastructure 
    def aMethod_max(self, argument): 
     if not hasattr(self, someVar): 
      self.aMethod(argument)   
     #do someting with self.var 
     return altered_var 

Но я считал это слишком сложно, и надеялся на более элегантное решение. Надеюсь, теперь ясно, чего я хочу достичь.

Поэтому я фантазировал о чем-то подобном в следующем параграфе.

class someClass(object): 
    someMethod(self): 
     #doSomething 
     return result 
    subMethod(self): 
     #doSomething with the result of someMethod 

Foo = someClass() 
Foo.someMethod.subMethod() 

или если SomeMethod имеет аргумент что-то вроде

Foo.someMethod(argument).subMethod() 

Как бы я сделать что-то подобное в Python?

EDIT: или вот так?

subMethod(self): 
    var = self.someMethod() 
    return doSomething(var) 

Answer 1

Давайте сравним существующие решения, уже заданные в вашем вопросе (например, те, которые вы называете «сложными» и «неэлегантными») с предложенной вами альтернативой.

Существующие решения означает, что вы сможете написать:

foo.subMethod() # foo.someMethod() is called internally 

но предложил ваша альтернатива означает, что вы должны написать:

foo.someMethod().subMethod() 

, который, очевидно, хуже.

С другой стороны, если subMethod должен быть в состоянии изменить результат любой метод, а не только someMethod, то существующие решения будет означать, вы должны написать:

foo.subMethod(foo.anyMethod()) 

с только недостаток заключается в том, что вы должны ввести foo дважды, в отличие от одного раза.

Заключение: в целом существующие решения являются менее сложными и неэлегантными, чем предлагаемая вами альтернатива - так придерживайтесь существующих решений.

Answer 2

Вы можете сделать method chaining когда результат SomeMethod является экземпляром SomeClass.

Простой пример:

>>> class someClass: 
... def someMethod(self): 
...  return self 
... def subMethod(self): 
...  return self.__class__ 
... 
>>> x=someClass() 
>>> x 
<__main__.someClass instance at 0x2aaaaab30d40> 
>>> x.someMethod().subMethod() 
<class __main__.someClass at 0x2aaaaab31050> 

Answer 3

Вы можете достичь что-то подобное с помощью декораторов:

def on_result(f): 
    def decorated(self,other,*args,**kwargs): 
     result = getattr(self,other)(*args,**kwargs) 
     return f(result) 
    return decorated 

Использование:

class someClass(object): 
    def someMethod(self,x,y): 
     #doSomething 
     result = [1,2,3,x,y] # example 
     return result 
    @on_result 
    def subMethod(self): 
     #doSomething with the result of someMethod 
     print self # example 

Foo = someClass() 
Foo.subMethod("someMethod",4,5) 

Выход:

[1, 2, 3, 4, 5] 

Как вы видите, первый аргумент - это имя метода, который должен быть привязан, а остальные будут переданы ему, независимо от его подписи.

EDIT: на второй мысли, это довольно бессмысленно, так как вы всегда можете использовать

Foo.submethod(Foo.someMethod(4,5))... 

Может быть, я не понимаю, что вы пытаетесь достичь. Нужно ли связать subMethod с методом ? Или, может быть, это синтаксическая форма

a.b().c() 

Это вам очень понравилось? (В этом случае, см ответ Кодзиро в)

Answer 4

Не уверен, что если я понять это правильно, но, возможно, вы имеете в виду это:

Foo.subMethod(Foo.someMethod()) 

Это передает результат SomeMethod() в subMethod(). Вам нужно будет изменить текущее определение subMethod(), чтобы принять результат someMethod().

Answer 5

С обратной связи до сих пор, я понимаю, что subMethod соединит только к SomeMethod, верно? Может быть, вы можете добиться этого сочетания декоратора с крышкой:

def on_result(other): 
    def decorator(f): 
     def decorated(self,*a1,**k1): 
      def closure(*a2,**k2): 
       return f(self,getattr(self,other)(*a1,**k1),*a2,**k2) 
      return closure 
     return decorated 
    return decorator 

class someClass(object): 
    def someMethod(self,a,b): 
     return [a,2*b] 
    @on_result('someMethod') 
    def subMethod(self,result,c,d): 
     result.extend([3*c,4*d]) 
     return result 

Foo = someClass() 
print Foo.subMethod(1,2)(3,4) # prints [1,4,9,16] 

Декоратор является своим родом «некрасиво», но когда-то написал его использование довольно элегантный ИМХО (плюс, нет контрсил в подписи любого метода) ,

Примечание: Я использую Python 2.5, и это единственный способ, которым я знаю, писать декораторы, которые принимают аргументы. Там, вероятно, лучший способ, но я слишком ленив, чтобы посмотреть его прямо сейчас ...