Odpowiednik NotImplementedError na polach w Pythonie

Question

w Pythonie 2.x, gdy chcesz oznaczyć metodę jako abstrakcyjne, można określić ją tak:

class Base: 
    def foo(self): 
     raise NotImplementedError("Subclasses should implement this!") 

Następnie, jeśli zapomni się go zastąpić, dostaniesz miły wyjątek przypomnienia. Czy istnieje równoważny sposób oznaczania pola jako abstrakcyjnego? Czy jest to stwierdzenie w klasie docstring, co możesz zrobić?

Początkowo myślałem, że mogę ustawić pole Nieemplementowane, ale kiedy spojrzałem w górę, do czego służy (porównanie bogate), wydawało się to nadużyciem.

Answer 1

Tak, możesz. Użyj dekoratora @property. Na przykład, jeśli masz pole o nazwie „przykład”, a następnie nie można zrobić coś takiego:

class Base(object): 

    @property 
    def example(self): 
     raise NotImplementedError("Subclasses should implement this!") 

uruchamiając następujące produkuje NotImplementedError tak jak chcesz.

b = Base() 
print b.example 

Answer 2

def require_abstract_fields(obj, cls): 
    abstract_fields = getattr(cls, "abstract_fields", None) 
    if abstract_fields is None: 
     return 

    for field in abstract_fields: 
     if not hasattr(obj, field): 
      raise RuntimeError, "object %s failed to define %s" % (obj, field) 

class a(object): 
    abstract_fields = ("x",) 
    def __init__(self): 
     require_abstract_fields(self, a) 

class b(a): 
    abstract_fields = ("y",) 
    x = 5 
    def __init__(self): 
     require_abstract_fields(self, b) 
     super(b, self).__init__() 

b() 
a() 

Uwaga przemijanie typu klasy w require_abstract_fields, więc jeśli kilka odziedziczone klasy korzystać z tego, że nie wszystko walidacji pól najbardziej pochodzący swojej klasie jest. Możesz zautomatyzować to za pomocą metaklasu, ale nie zagłębiłem się w to. Definiowanie pola na Brak jest akceptowane.

Answer 3

odpowiedź Alternatywny:

@property 
def NotImplementedField(self): 
    raise NotImplementedError 

class a(object): 
    x = NotImplementedField 

class b(a): 
    # x = 5 
    pass 

b().x 
a().x 

To jak Evan, ale zwięzły i tanio - you'll dostać tylko jedno wystąpienie NotImplementedField.

Answer 4

I tu jest moje rozwiązanie:

def not_implemented_method(func): 
    from functools import wraps 
    from inspect import getargspec, formatargspec 

    @wraps(func) 
    def wrapper(self, *args, **kwargs): 
     c = self.__class__.__name__ 
     m = func.__name__ 
     a = formatargspec(*getargspec(func)) 
     raise NotImplementedError('\'%s\' object does not implement the method \'%s%s\'' % (c, m, a)) 

    return wrapper 


def not_implemented_property(func): 
    from functools import wraps 
    from inspect import getargspec, formatargspec 

    @wraps(func) 
    def wrapper(self, *args, **kwargs): 
     c = self.__class__.__name__ 
     m = func.__name__ 
     raise NotImplementedError('\'%s\' object does not implement the property \'%s\'' % (c, m)) 

    return property(wrapper, wrapper, wrapper) 

Może być używany jako

class AbstractBase(object): 
    @not_implemented_method 
    def test(self): 
     pass 

    @not_implemented_property 
    def value(self): 
     pass 

class Implementation(AbstractBase): 
    value = None 

    def __init__(self): 
     self.value = 42 

    def test(self): 
     return True 

Answer 5

lepszy sposób to zrobić jest użycie Abstract Base Classes:

import abc 

class Foo(abc.ABC): 

    @property 
    @abc.abstractmethod 
    def demo_attribute(self): 
     raise NotImplementedError 

    @abc.abstractmethod 
    def demo_method(self): 
     raise NotImplementedError 

class BadBar(Foo): 
    pass 

class GoodBar(Foo): 

    demo_attribute = 'yes' 

    def demo_method(self): 
     return self.demo_attribute 

bad_bar = BadBar() 
# TypeError: Can't instantiate abstract class BadBar \ 
# with abstract methods demo_attribute, demo_method 

good_bar = GoodBar() 
# OK 

pamiętać, że powinien nadal masz raise NotImplementedError zamiast czegoś podobnego do pass, ponieważ nic nie stoi na przeszkodzie, aby klasa dziedzicząca dzwoniła pod numer super().demo_method(), a jeśli abstrakcyjne demo_method jest tylko pass, nie powiedzie się to po cichu.