Have a look at abc module. For 2.7: link. For 3.6: link Simple example for you: from abc import ABC, abstractmethod class A(ABC): def __init__(self, value): self.value = value super().__init__() @abstractmethod def do_something(self): pass class B(A): @abstractmethod def do_something_else(self): pass class C(B): def do_something(self): pass def do_something_else(self): pass
I would code it as two different methods just like in standard method factory pattern description. https://www.oodesign.com/factory-method-pattern.html class Foo(object): __metaclass__ = abc.ABCMeta @abc.abstractmethod @some_decorator def my_method(self, x): self.child_method() class SubFoo(Foo): def child_method(self, x): print x
No checks are done on how many arguments concrete implementations take. So there is nothing stopping your from doing this already. Just define those methods to take whatever parameters you need to accept: class View(metaclass=ABCMeta): @abstractmethod def set(self): pass @abstractmethod def get(self): pass class ConcreteView1(View): def set(self, param1): # implemenation def get(self, param1, param2): # … Read more
import inspect print(inspect.isabstract(object)) # False print(inspect.isabstract(MessageDisplay)) # True print(inspect.isabstract(FriendlyMessageDisplay)) # True print(inspect.isabstract(FriendlyMessagePrinter)) # False This checks that the internal flag TPFLAGS_IS_ABSTRACT is set in the class object, so it can’t be fooled as easily as your implementation: class Fake: __abstractmethods__ = ‘bluh’ print(is_abstract(Fake), inspect.isabstract(Fake)) # True, False
Numpy has a hierarchy of dtypes similar to a class hierarchy (the scalar types actually have a bona fide class hierarchy that mirrors the dtype hierarchy). You can use np.issubdtype(some_dtype, np.integer) to test if a dtype is an integer dtype. Note that like most dtype-consuming functions, np.issubdtype() will convert its arguments to dtypes, so anything … Read more
For me the best solution was what @Wesley mentioned in his comment to the accepted answer, specifically replacing ‘pass’ with a docstring for the abstract property, e.g.: class MyAbstractClass(object): __metaclass__ = ABCMeta @abstractproperty def myproperty(self): “”” this property is too abstract to understand. “””
You could use six.add_metaclass or six.with_metaclass: import abc, six @six.add_metaclass(abc.ABCMeta) class SomeAbstractClass(): @abc.abstractmethod def do_something(self): pass six is a Python 2 and 3 compatibility library. You can install it by running pip install six or by downloading the latest version of six.py to your project directory. For those of you who prefer future over six, … Read more
In newer versions of Python you can use unittest.mock.patch() class MyAbcClassTest(unittest.TestCase): @patch.multiple(MyAbcClass, __abstractmethods__=set()) def test(self): self.instance = MyAbcClass() # Ha!
Are you using python3 to run that code? If yes, you should know that declaring metaclass in python3 have changes you should do it like this instead: import abc class AbstractClass(metaclass=abc.ABCMeta): @abc.abstractmethod def abstractMethod(self): return The full code and the explanation behind the answer is: import abc class AbstractClass(metaclass=abc.ABCMeta): @abc.abstractmethod def abstractMethod(self): return class ConcreteClass(AbstractClass): … Read more
@Oddthinking’s answer is not wrong, but I think it misses the real, practical reason Python has ABCs in a world of duck-typing. Abstract methods are neat, but in my opinion they don’t really fill any use-cases not already covered by duck typing. Abstract base classes’ real power lies in the way they allow you to … Read more