세 가지 방법을 순환 방식으로 정의하는 방법은 무엇입니까?

Question

나는 상응하는 의미의 세 가지 메소드를 가진 추상 클래스를 가지고있다 - 그들은 비싼 변환 함수를 사용하여 서로의 관점에서 정의 될 수있다. 나는 메소드 중 하나를 오버라이드하고 자동으로 다른 두 개를 얻는 데 필요한 파생 클래스를 작성할 수 있기를 원합니다. 예

class FooBarBaz(object): 
    def foo(self, x): 
     return foo_from_bar(self.bar(x)) 
     # OR return foo_from_baz(self.baz(x)) 

    def bar(self, x): 
     return bar_from_foo(self.foo(x)) 
     # OR return bar_from_baz(self.baz(x)) 

    def baz(self, x): 
     return baz_from_bar(self.bar(x)) 
     # OR return baz_from_foo(self.foo(x)) 

class Derived1(FooBarBaz): 
    def bar(self, x): 
     return 5 
     # at this point foo = foo_from_bar(5) and 
     # baz = baz_from_bar(5), which is what I wanted 

class Derived2(FooBarBaz): 
    def foo(self, x): 
     return 6 
     # at this point bar = bar_from_foo(6) and 
     # baz = baz_from_bar(bar_from_foo(6)), 
     # which is not ideal, but still works 

class Derived3(FooBarBaz): 
    def baz(self, x): 
     return 7 
     # at this point foo and bar remain defined 
     # in terms of each other, which is a PROBLEM 

나는 각 변환 클래스에 사용할 변환을 명시 적으로 알 수 있습니다. 부모 클래스가 자식을 수정하지 않고이를 스스로 알아낼 수있는 방법이 있는지 알고 싶습니다.

Answer 1

남은 메서드를 자동으로 채우는 메타 클래스 작성과 같은 메타 프로그래밍 기법을 사용하거나, 내성 검사를 사용하여 type(self).mro()의 클래스를 차례로 보면 어떤 메서드가 재정의되었는지 확인할 수 있습니다. 그러나 이러한 옵션은 나를 위해 "너무 많은 마법"범주에 빠지기 때문에 좀 더 간단하게 처리 할 것입니다.

각 메소드를 두 개의 메소드로 분리하십시오. 하나는 일반적인 메소드이고 실제 구현은 하나입니다.

class FooBarBaz(object): 

    def foo_impl(self, x): 
     raise NotImplementedError 

    def foo(self, x): 
     try: 
      return self.foo_impl(x) 
     except NotImplementedError: 
      try: 
       return foo_from_bar(self.bar_impl(x)) 
      except NotImplementedError: 
       return foo_from_baz(self.baz_impl(x)) 

    # Similarly fo bar and baz 

class Dervied(FooBarBaz): 

    def bar_impl(self, x): 
     return 5 

일반적인 논리

도 장식에서 고려 될 수있다 :

def first_implemented(func): 
    @functools.wraps 
    def wrapper(*args, **kwargs): 
     for f in func(*args, **kwargs): 
      try: 
       return f() 
      except NotImplementedError: 
       pass 
     raise NotImplementedError 
    return wrapper 

class FooBarBaz(object): 

    def foo_impl(self, x): 
     raise NotImplementedError 

    @first_implemented 
    def foo(self, x): 
     yield lambda: self.foo_impl(x) 
     yield lambda: foo_from_bar(self.bar_impl(x)) 
     yield lambda: foo_from_baz(self.baz_impl(x)) 

Answer 2

깨끗한 원으로 전환을 정의하여 한 가지 방법을 다시 정의하면 해당 원이 깨질 수 있습니다. 같은 문제에 코멘트와 함께 동시에 편집

class FooBarBaz(object): 
    def foo(self, x): 
     return foo_from_baz(self.baz(x)) 

    def bar(self, x): 
     return bar_from_foo(self.foo(x)) 

    def baz(self, x): 
     return baz_from_bar(self.bar(x)) 

이 제기되고 : : 즉 작동합니다,하지만 물론, 때로는 두 번 변환해야합니다. 이를 방지하기 위해 일종의 지연 평가를 구현할 수 있습니다. 즉, 함수가 먼저 자체를 평가하는 방법을 알고있는 객체를 생성하지만, 먼저 값을 요청하면 함수가 수행됩니다. 그렇게하면 비용이 많이 소요되는 경우 평가 전에 변환 체인을 단순화 할 수 있습니다.

Answer 3

실제로 Dr. V's answer을 복제하고 파생 클래스는 실제 구현을 재정의합니다. 내가 코드를 작성 소요되는 노력을 정당화하기 위해 내 대답을 게시하고있다 :

#!/usr/bin/env python 
def foo_from_bar(x): 
    return 'foo_from_bar(%s)' % x 

def bar_from_baz(x): 
    return 'bar_from_baz(%s)' % x 

def baz_from_foo(x): 
    return 'baz_from_foo(%s)' % x 

class FooBarBaz(object): 
    def foo(self, x): 
     return foo_from_bar(self.bar(x)) 

    def bar(self, x): 
     return bar_from_baz(self.baz(x)) 

    def baz(self, x): 
     return baz_from_foo(self.foo(x)) 

class Derived1(FooBarBaz): 
    def bar(self, x): 
     return 5 

class Derived2(FooBarBaz): 
    def foo(self, x): 
     return 6 

class Derived3(FooBarBaz): 
    def baz(self, x): 
     return 7 

d1 = Derived1() 
d2 = Derived2() 
d3 = Derived3() 

def check(expr): 
    print expr, '->', eval(expr) 

for i,d in enumerate([d1, d2, d3]): 
    print '--- d = Derived%d() ----' % (i+1) 
    check('d.foo(0)') 
    check('d.bar(0)') 
    check('d.baz(0)') 

출력 :

--- d = Derived1() ---- 
d.foo(0) -> foo_from_bar(5) 
d.bar(0) -> 5 
d.baz(0) -> baz_from_foo(foo_from_bar(5)) 
--- d = Derived2() ---- 
d.foo(0) -> 6 
d.bar(0) -> bar_from_baz(baz_from_foo(6)) 
d.baz(0) -> baz_from_foo(6) 
--- d = Derived3() ---- 
d.foo(0) -> foo_from_bar(bar_from_baz(7)) 
d.bar(0) -> bar_from_baz(7) 
d.baz(0) -> 7 

Answer 4

데코레이터 또한 트릭을 할 수 있습니다. 이 라인을 따라 뭔가 :

이

def define_missing(cls): 
    has_at_least_one = False 
    if hasattr(cls, 'foo'): 
     if not hasattr(cls, 'bar'): 
      cls.bar = lambda self, x: bar_from_foo(self.foo(x)) 
     if not hasattr(cls, 'baz'): 
      cls.baz = lambda self, x: baz_from_foo(self.foo(x)) 
     has_at_least_one = True 
    if hasattr(cls, 'bar'): 
     if not hasattr(cls, 'foo'): 
      cls.foo = lambda self, x: foo_from_bar(self.bar(x)) 
     if not hasattr(cls, 'baz'): 
      cls.baz = lambda self, x: baz_from_bar(self.bar(x)) 
     has_at_least_one = True 
    if hasattr(cls, 'baz'): 
     if not hasattr(cls, 'bar'): 
      cls.foo = lambda self, x: foo_from_baz(self.baz(x)) 
     if not hasattr(cls, 'baz'): 
      cls.bar = lambda self, x: bar_from_baz(self.baz(x)) 
     has_at_least_one = True 
    if not has_at_least_one: 
     raise TypeError("Class needs to implement at least one of the methods foo, bar, and baz.") 
    return cls 

다음과 같이 사용 :

@define_missing 
class Derived1(FooBarBaz): 
    def bar(self, x): 
     return 5 

이이 functools.total_ordering 장식에서 영감을.