Pythonでクラスまたはメソッドを抽象化するにはどうすればよいですか？
私は__new__()そのように再定義しようとしました：
class F:
def __new__(cls):
raise Exception("Unable to create an instance of abstract class %s" %cls)
しかし今、私がそのようGに継承するクラスを作成するとF：
class G(F):
pass
その場合、スーパークラスのメソッドGを呼び出すため、インスタンス化することもできません。__new__
抽象クラスを定義するためのより良い方法はありますか？
モジュールを使用abcして抽象クラスを作成します。デコレータを使用abstractmethodしてメソッド抽象を宣言し、Pythonのバージョンに応じて、3つの方法のいずれかを使用してクラス抽象を宣言します。
Python 3.4以降では、から継承できますABC。以前のバージョンのPythonでは、クラスのメタクラスをとして指定する必要がありますABCMeta。メタクラスの指定は、Python3とPython2で構文が異なります。3つの可能性を以下に示します。
# Python 3.4+
from abc import ABC, abstractmethod
class Abstract(ABC):
@abstractmethod
def foo(self):
pass
# Python 3.0+
from abc import ABCMeta, abstractmethod
class Abstract(metaclass=ABCMeta):
@abstractmethod
def foo(self):
pass
# Python 2
from abc import ABCMeta, abstractmethod
class Abstract:
__metaclass__ = ABCMeta
@abstractmethod
def foo(self):
pass
どちらの方法を使用しても、抽象メソッドを持つ抽象クラスをインスタンス化することはできませんが、それらのメソッドの具体的な定義を提供するサブクラスをインスタンス化することはできます。
>>> Abstract()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: Can't instantiate abstract class Abstract with abstract methods foo
>>> class StillAbstract(Abstract):
... pass
...
>>> StillAbstract()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: Can't instantiate abstract class StillAbstract with abstract methods foo
>>> class Concrete(Abstract):
... def foo(self):
... print('Hello, World')
...
>>> Concrete()
<__main__.Concrete object at 0x7fc935d28898>
これを行うための昔ながらの（PEP 3119以前の）方法raise NotImplementedErrorは、抽象メソッドが呼び出されたときに抽象クラスで行うことです。
class Abstract(object):
def foo(self):
raise NotImplementedError('subclasses must override foo()!')
class Derived(Abstract):
def foo(self):
print 'Hooray!'
>>> d = Derived()
>>> d.foo()
Hooray!
>>> a = Abstract()
>>> a.foo()
Traceback (most recent call last): [...]
abcこれには、モジュールを使用する場合と同じ優れたプロパティはありません。抽象基本クラス自体をインスタンス化することはできますが、実行時に抽象メソッドを呼び出すまで間違いを見つけることはできません。
ただし、単純なクラスの小さなセットを扱っている場合、おそらくいくつかの抽象的なメソッドを使用している場合、このアプローチは、abcドキュメントを調べてみるよりも少し簡単です。
これは、ABCモジュールを処理することなく非常に簡単な方法です。
__init__抽象クラスにしたいクラスのメソッドで、自分の「型」を確認できます。自己のタイプが基本クラスである場合、呼び出し元は基本クラスをインスタンス化しようとしているため、例外を発生させます。簡単な例を次に示します。
class Base():
def __init__(self):
if type(self) is Base:
raise Exception('Base is an abstract class and cannot be instantiated directly')
# Any initialization code
print('In the __init__ method of the Base class')
class Sub(Base):
def __init__(self):
print('In the __init__ method of the Sub class before calling __init__ of the Base class')
super().__init__()
print('In the __init__ method of the Sub class after calling __init__ of the Base class')
subObj = Sub()
baseObj = Base()
実行すると、次のようになります。
In the __init__ method of the Sub class before calling __init__ of the Base class
In the __init__ method of the Base class
In the __init__ method of the Sub class after calling __init__ of the Base class
Traceback (most recent call last):
File "/Users/irvkalb/Desktop/Demo files/Abstract.py", line 16, in <module>
baseObj = Base()
File "/Users/irvkalb/Desktop/Demo files/Abstract.py", line 4, in __init__
raise Exception('Base is an abstract class and cannot be instantiated directly')
Exception: Base is an abstract class and cannot be instantiated directly
これは、基本クラスから継承するサブクラスをインスタンス化できるが、基本クラスを直接インスタンス化できないことを示しています。
以前のほとんどの回答は正しかったですが、ここにPython3.7の回答と例があります。はい、抽象クラスとメソッドを作成できます。念のために言っておきますが、クラスは論理的にクラスに属するメソッドを定義する必要がありますが、そのクラスはメソッドの実装方法を指定できません。たとえば、以下の親と赤ちゃんのクラスでは、両方が食べますが、赤ちゃんと親は異なる種類の食べ物を食べ、食べる回数が異なるため、実装はそれぞれ異なります。したがって、eatメソッドのサブクラスはAbstractClass.eatをオーバーライドします。
from abc import ABC, abstractmethod
class AbstractClass(ABC):
def __init__(self, value):
self.value = value
super().__init__()
@abstractmethod
def eat(self):
pass
class Parents(AbstractClass):
def eat(self):
return "eat solid food "+ str(self.value) + " times each day"
class Babies(AbstractClass):
def eat(self):
return "Milk only "+ str(self.value) + " times or more each day"
food = 3
mom = Parents(food)
print("moms ----------")
print(mom.eat())
infant = Babies(food)
print("infants ----------")
print(infant.eat())
出力：
moms ----------
eat solid food 3 times each day
infants ----------
Milk only 3 times or more each day
他の回答で説明されているように、はい、abcモジュールを使用してPythonで抽象クラスを使用できます。@classmethod以下に、abstract 、@propertyおよび@abstractmethod（Python 3.6以降を使用）を使用した実際の例を示します。私にとっては、通常、簡単にコピーして貼り付けることができる例から始めるほうが簡単です。この回答が他の人にも役立つことを願っています。
まず、次のような基本クラスを作成しましょうBase。
from abc import ABC, abstractmethod
class Base(ABC):
@classmethod
@abstractmethod
def from_dict(cls, d):
pass
@property
@abstractmethod
def prop1(self):
pass
@property
@abstractmethod
def prop2(self):
pass
@prop2.setter
@abstractmethod
def prop2(self, val):
pass
@abstractmethod
def do_stuff(self):
pass
私たちのクラスには、Base常に、、（読み取り専用）、a （設定も可能）、および。という関数があります。現在構築されているクラスが何であれ、これら4つのメソッド/プロパティをすべて実装する必要があります。メソッドを抽象化するには、2つのデコレータ（およびabstract ）が必要であることに注意してください。from_dict classmethodproperty prop1property prop2do_stuffBaseclassmethodproperty
Aこれで、次のようなクラスを作成できます。
class A(Base):
def __init__(self, name, val1, val2):
self.name = name
self.__val1 = val1
self._val2 = val2
@classmethod
def from_dict(cls, d):
name = d['name']
val1 = d['val1']
val2 = d['val2']
return cls(name, val1, val2)
@property
def prop1(self):
return self.__val1
@property
def prop2(self):
return self._val2
@prop2.setter
def prop2(self, value):
self._val2 = value
def do_stuff(self):
print('juhu!')
def i_am_not_abstract(self):
print('I can be customized')
必要なすべてのメソッド/プロパティが実装されており、もちろん、一部ではない関数を追加することもできますBase（ここでは:) i_am_not_abstract。
今、私たちはできる：
a1 = A('dummy', 10, 'stuff')
a2 = A.from_dict({'name': 'from_d', 'val1': 20, 'val2': 'stuff'})
a1.prop1
# prints 10
a1.prop2
# prints 'stuff'
必要に応じて、設定することはできませんprop1：
a.prop1 = 100
戻ります
AttributeError：属性を設定できません
また、私たちのfrom_dict方法はうまく機能します：
a2.prop1
# prints 20
ここで、次のような2番目のクラスを定義した場合B：
class B(Base):
def __init__(self, name):
self.name = name
@property
def prop1(self):
return self.name
そして、次のようなオブジェクトをインスタンス化しようとしました：
b = B('iwillfail')
エラーが発生します
TypeError：抽象メソッドdo_stuff、from_dict、prop2で抽象クラスBをインスタンス化できません
Baseで実装しなかった定義済みのものをすべてリストしBます。
これはPython3で動作します
from abc import ABCMeta, abstractmethod
class Abstract(metaclass=ABCMeta):
@abstractmethod
def foo(self):
pass
Abstract()
>>> TypeError: Can not instantiate abstract class Abstract with abstract methods foo
また、これは機能し、簡単です。
class A_abstract(object):
def __init__(self):
# quite simple, old-school way.
if self.__class__.__name__ == "A_abstract":
raise NotImplementedError("You can't instantiate this abstract class. Derive it, please.")
class B(A_abstract):
pass
b = B()
# here an exception is raised:
a = A_abstract()
__new__メソッドを利用することもできます。あなたはただ何かを忘れました。__new__メソッドは常に新しいオブジェクトを返すため、スーパークラスの新しいメソッドを返す必要があります。次のようにします。
class F:
def __new__(cls):
if cls is F:
raise TypeError("Cannot create an instance of abstract class '{}'".format(cls.__name__))
return super().__new__(cls)
新しいメソッドを使用する場合は、Noneキーワードではなく、オブジェクトを返す必要があります。それはあなたが逃したすべてです。
受け入れられた答えと他のすべての答えはself、抽象クラスに渡されるため、奇妙だと思います。抽象クラスはインスタンス化されないため、を持つことはできませんself。
だからこれを試してみてください、それはうまくいきます。
from abc import ABCMeta, abstractmethod
class Abstract(metaclass=ABCMeta):
@staticmethod
@abstractmethod
def foo():
"""An abstract method. No need to write pass"""
class Derived(Abstract):
def foo(self):
print('Hooray!')
FOO = Derived()
FOO.foo()
from abc import ABCMeta, abstractmethod
#Abstract class and abstract method declaration
class Jungle(metaclass=ABCMeta):
#constructor with default values
def __init__(self, name="Unknown"):
self.visitorName = name
def welcomeMessage(self):
print("Hello %s , Welcome to the Jungle" % self.visitorName)
# abstract method is compulsory to defined in child-class
@abstractmethod
def scarySound(self):
pass
ここで答えるのは遅いですが、ここで指摘している他の質問「抽象的なメソッドの作り方」に答えるために、私は以下を提供します。
# decorators.py
def abstract(f):
def _decorator(*_):
raise NotImplementedError(f"Method '{f.__name__}' is abstract")
return _decorator
# yourclass.py
class Vehicle:
def add_energy():
print("Energy added!")
@abstract
def get_make(): ...
@abstract
def get_model(): ...
クラスベースのVehicleクラスは、単体テスト用にインスタンス化でき（ABCとは異なり）、Pythonicによる例外の発生が存在します。そうです、便宜上、このメソッドを除いて抽象的なメソッド名も取得します。
コードスニペットでは、次のよう__new__に、サブクラスのメソッドの実装を提供することでこれを解決することもできます。
def G(F):
def __new__(cls):
# do something here
しかし、これはハックであり、自分が何をしているのかわからない限り、これに反対することをお勧めします。ほとんどすべての場合abc、私の前に他の人が提案したモジュールを使用することをお勧めします。
また、新しい（基本）クラスを作成するときは、次のようにサブクラスobjectにしますclass MyBaseClass(object):。それがもうそれほど重要かどうかはわかりませんが、コードのスタイルの一貫性を維持するのに役立ちます
@TimGilbertの昔ながらの答えに簡単に追加すると、抽象基本クラスのinit（）メソッドに例外をスローさせることができます。これにより、インスタンス化が妨げられます。
>>> class Abstract(object):
... def __init__(self):
... raise NotImplementedError("You can't instantiate this class!")
...
>>> a = Abstract()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<stdin>", line 3, in __init__
NotImplementedError: You can't instantiate this class!