Pythonで抽象クラスを作成することは可能ですか?


321

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(抽象基本クラス)モジュールを使用して、Pythonで抽象クラスを作成できます。このサイトはあなたを助けるでしょう:http
ORION

回答:


554

abcモジュールを使用して抽象クラスを作成します。abstractmethodデコレータを使用してメソッドの抽象を宣言し、Pythonのバージョンに応じて3つの方法のいずれかを使用してクラスの抽象を宣言します。

Python 3.4以降では、から継承できますABC。以前のバージョンのPythonでは、クラスのメタクラスをとして指定する必要がありますABCMeta。Python 3とPython 2ではメタクラスを指定する構文が異なります。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>

9
@abstractmethodは何をしますか?なぜあなたはそれが必要なのですか?クラスがすでに抽象クラスとして確立されている場合、コンパイラー/インタープリターは、すべてのメソッドが問題の抽象クラスからのものであることを知ってはいけませんか?
チャーリーパーカー、

29
@CharlieParker- は、クラスをインスタンス化する前に、@abstractmethod装飾された関数をオーバーライドする必要があるようにします。ドキュメントから:A class that has a metaclass derived from ABCMeta cannot be instantiated unless all of its abstract methods and properties are overridden.
偽の名前

6
@CharlieParker-基本的に、インスタンス化するためにサブクラスが指定された一連のメソッドを実装する必要がある方法でクラスを定義できます。
偽の名前

13
@abstractmethodメソッドなしでユーザーがAbstract()を作成できないようにする方法はありますか?
Joe

2
あなたが使用することができます表示されます@Joe @abstractmethodため__init__にも方法、参照stackoverflow.com/q/44800659/547270
scrutari

108

これを行う旧式の(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ドキュメントを調べていくよりも少し簡単です。


1
このアプローチのシンプルさと効果を高く評価してください。
mohit6up

はは、私はこれを私のOMSCSコースのいたるところで見ました、そしてそれが何であったかについての手がかりがありませんでした:)
mLstudent33

18

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

これは、基本クラスから継承するサブクラスをインスタンス化できるが、基本クラスを直接インスタンス化できないことを示しています。


11

以前のほとんどの答えは正しかったですが、Python 3.7の答えと例を次に示します。はい、抽象クラスとメソッドを作成できます。リマインダーと同じように、クラスは論理的にクラスに属するメソッドを定義する必要がありますが、そのクラスはメソッドの実装方法を指定できません。たとえば、以下のParentsクラスとBabysクラスでは、どちらも食べますが、赤ちゃんと両親は異なる種類の食品を食べ、食べる回数も異なるため、それぞれの実装は異なります。したがって、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

おそらくimport abc役に立たないでしょう。
Benyamin Jafari

init関数にも@abstractmethodを記述できますか?
変数

+1なぜ@abstractmethod def eat(self)なのですか?このクラスが抽象的であり、したがってインスタンス化することを意図していない場合、なぜ(自己)を渡して食べるのですか?それなしでも問題なく動作します
VMMF

7

これはPython 3で動作します

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

4

他の回答で説明したように、はい、abcモジュールを使用してPythonで抽象クラスを使用できます。私は、抽象使って、実際の例を与えるの下@classmethod@propertyおよび@abstractmethod(3.6以降のPythonを使用して)。私にとっては、通常、簡単にコピーして貼り付けることができる例から始める方が簡単です。この答えが他の人にも役立つことを願っています。

まず、次の基本クラスを作成します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クラスには常に、、from_dict classmethoda property prop1(読み取り専用)、a property prop2(設定も可能)と呼ばれる関数がありdo_stuffます。現在基づいて構築されているクラスはBase、メソッド/プロパティに対してこれらすべてを実装する必要があります。メソッドを抽象化するには、2つのデコレータが必要であることに注意してください- classmethodとabstract propertyです。

これで、次の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

次のBような2番目のクラスを定義したとします。

class B(Base):
    def __init__(self, name):
        self.name = name

    @property
    def prop1(self):
        return self.name

そして、このようなオブジェクトをインスタンス化しようとしました:

b = B('iwillfail')

エラーが発生します

TypeError:抽象メソッドBを抽象メソッドdo_stuff、from_dict、prop2でインスタンス化できません

Base実装していない定義済みのものをすべてリストしBます。


2

これも機能し、簡単です:

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()

2

__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キーワードではなくオブジェクトを返す必要があります。それはあなたが逃したすべてです。


2

彼ら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()

1
でも、ABCドキュメントの使用自己彼らの例では、リンク
スミルノフイゴール

2
 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

素敵な@Shivam Bharadwaj、私は同じ方法でやりました
Muhammad Irfan

-3

コードスニペット__new__では、同様に、サブクラスのメソッドの実装を提供することで、これを解決することもできます。

def G(F):
    def __new__(cls):
        # do something here

しかし、これはハックであり、あなたが何をしているかを知らない限り、私はそれに対してあなたに助言します。ほとんどすべてのケースで、私はあなたがこのabcモジュールを使用することをお勧めします。

また、新しい(ベース)クラスを作成するときは、次のようにサブクラスobjectにしますclass MyBaseClass(object):。それほど重要かどうかはわかりませんが、コードのスタイルの一貫性を維持するのに役立ちます


-4

@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! 

6
これにより、サブクラスが、共通の基本クラスに論理的に存在する必要のある一般的な初期化コードの恩恵を受けることがなくなります。
Arpit Singh 2017

けっこうだ。オールドスクールにはそんなにたくさん。
Dave Wade-Stein
弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.