เป็นไปได้ไหมที่จะสร้างคลาสนามธรรมใน Python?

ฉันจะทำให้คลาสหรือวิธีการเป็นนามธรรมใน 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มัณฑนากรเพื่อประกาศเมธอด abstract และประกาศ abstract class โดยใช้หนึ่งในสามวิธีขึ้นอยู่กับเวอร์ชัน Python ของคุณ

ใน Python 3.4 ขึ้นไปคุณสามารถรับช่วงABCต่อได้ ในเวอร์ชันก่อนหน้าของงูใหญ่, คุณจะต้องระบุ metaclass ABCMetaระดับของคุณเป็น การระบุ metaclass มีรูปแบบที่แตกต่างกันใน Python 3 และ Python 2 ความเป็นไปได้สามอย่างดังแสดงด้านล่าง:

# 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โมดูล คุณยังสามารถสร้างอินสแตนซ์คลาส abstract ได้เองและคุณจะไม่พบข้อผิดพลาดจนกว่าคุณจะเรียกเมธอด abstract ที่ runtime

แต่ถ้าคุณกำลังจัดการกับคลาสแบบง่าย ๆ ชุดเล็ก ๆ , บางทีอาจจะมีเพียงแค่วิธีนามธรรม, วิธีนี้ง่ายกว่าการลองดู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

นี่แสดงว่าคุณสามารถยกตัวอย่างคลาสย่อยที่สืบทอดจากคลาสพื้นฐาน แต่คุณไม่สามารถสร้างอินสแตนซ์คลาสพื้นฐานได้โดยตรง

คำตอบก่อนหน้านี้ส่วนใหญ่ถูกต้อง แต่นี่คือคำตอบและตัวอย่างสำหรับPython 3.7 ใช่คุณสามารถสร้างคลาสและวิธีการที่เป็นนามธรรม เช่นเดียวกับการเตือนความจำบางครั้งคลาสควรกำหนดวิธีการที่มีเหตุผลในชั้นเรียน แต่ชั้นนั้นไม่สามารถระบุวิธีการใช้วิธีการ ตัวอย่างเช่นในชั้นเรียนผู้ปกครองและทารกด้านล่างพวกเขาทั้งสองกิน แต่การใช้งานจะแตกต่างกันไปสำหรับแต่ละคนเพราะเด็กและผู้ปกครองกินอาหารประเภทที่แตกต่างกันและจำนวนครั้งที่พวกเขากินจะแตกต่างกัน ดังนั้นกิน subclasses ของเมธอดแทนที่ 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

อันนี้จะทำงานในหลาม 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

ตามที่อธิบายไว้ในคำตอบอื่น ๆ ใช่คุณสามารถใช้คลาสนามธรรมในหลามใช้โมดูลabc ด้านล่างนี้ผมให้เป็นตัวอย่างที่เกิดขึ้นจริงโดยใช้นามธรรม@classmethod, @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ระดับมักจะมีfrom_dict classmethodการproperty prop1(ซึ่งก็คืออ่านอย่างเดียว) และproperty prop2(ซึ่งยังสามารถตั้งค่า) do_stuffเช่นเดียวกับฟังก์ชั่นที่เรียกว่า ไม่ว่าคลาสใดที่ถูกสร้างขึ้นโดยBaseจะต้องใช้สิ่งเหล่านี้ทั้งหมดสำหรับเมธอด / คุณสมบัติ โปรดทราบว่าสำหรับวิธีการที่จะเป็นนามธรรมสองตกแต่งจะต้อง - และนามธรรมclassmethodproperty

ตอนนี้เราสามารถสร้างคลาส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ดังนี้:

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

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

และพยายามยกตัวอย่างวัตถุเช่นนี้:

b = B('iwillfail')

เราจะได้รับข้อผิดพลาด

TypeError: ไม่สามารถยกตัวอย่างคลาสนามธรรม B ด้วยเมธอด abstract do_stuff, from_dict, prop2

รายชื่อทุกสิ่งที่กำหนดไว้ในที่ที่เราไม่ได้ใช้ในBaseB

ยังใช้งานได้และง่าย:

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ไปยังชั้นนามธรรม ระดับนามธรรมไม่ได้ instantiated 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

ในข้อมูลโค้ดของคุณคุณสามารถแก้ไขปัญหานี้ได้ด้วยการนำเสนอ__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!