É possível criar classes abstratas em Python?

Como posso tornar uma classe ou método abstrato em Python?

Tentei redefinir __new__()assim:

class F:
    def __new__(cls):
        raise Exception("Unable to create an instance of abstract class %s" %cls)

mas agora se eu criar uma classe Gque herda da seguinte Fmaneira:

class G(F):
    pass

também não posso instanciar G, pois chama o __new__método da sua superclasse .

Existe uma maneira melhor de definir uma classe abstrata?

Use o abcmódulo para criar classes abstratas. Use o abstractmethoddecorador para declarar um resumo do método e declare um resumo da classe usando uma das três maneiras, dependendo da sua versão do Python.

No Python 3.4 e superior, você pode herdar de ABC. Nas versões anteriores do Python, você precisa especificar a metaclasse da sua classe como ABCMeta. A especificação da metaclasse possui sintaxe diferente no Python 3 e Python 2. As três possibilidades são mostradas abaixo:

# 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

Qualquer que seja a maneira que você use, você não poderá instanciar uma classe abstrata que possua métodos abstratos, mas poderá instanciar uma subclasse que fornece definições concretas desses métodos:

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

A maneira da velha escola (antes do PEP 3119 ) de fazer isso é apenas raise NotImplementedErrorna classe abstrata quando um método abstrato é chamado.

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): [...]

Isso não tem as mesmas boas propriedades que o abcmódulo. Você ainda pode instanciar a própria classe base abstrata e não encontrará seu erro até chamar o método abstrato em tempo de execução.

Mas se você está lidando com um pequeno conjunto de classes simples, talvez com apenas alguns métodos abstratos, essa abordagem é um pouco mais fácil do que tentar percorrer a abcdocumentação.

Aqui está uma maneira muito fácil, sem ter que lidar com o módulo ABC.

No __init__método da classe que você deseja que seja uma classe abstrata, você pode verificar o "tipo" de si mesmo. Se o tipo de self for a classe base, o chamador está tentando instanciar a classe base, portanto, crie uma exceção. Aqui está um exemplo simples:

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

Quando executado, produz:

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

Isso mostra que você pode instanciar uma subclasse que herda de uma classe base, mas não pode instanciar a classe base diretamente.

A maioria das respostas anteriores estava correta, mas aqui está a resposta e o exemplo para o Python 3.7. Sim, você pode criar uma classe e método abstratos. Assim como um lembrete, às vezes, uma classe deve definir um método que pertence logicamente a uma classe, mas essa classe não pode especificar como implementar o método. Por exemplo, nas classes Pais e bebês abaixo, ambos comem, mas a implementação será diferente para cada um deles, porque bebês e pais comem um tipo diferente de comida e o número de vezes que comem é diferente. Portanto, as subclasses de método eat substituem 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())

RESULTADO:

moms ----------
eat solid food 3 times each day
infants ----------
Milk only 3 times or more each day

Este estará trabalhando em 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

Como explicado em outras respostas, sim, você pode usar classes abstratas em Python utilizando o abcmódulo . Abaixo eu dar um exemplo real usando abstrato @classmethod, @propertye @abstractmethod(usando Python 3.6+). Para mim, geralmente é mais fácil começar com exemplos que eu posso copiar e colar facilmente; Espero que esta resposta também seja útil para outros.

Vamos primeiro criar uma classe base chamada 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

Nossa Baseclasse sempre terá a from_dict classmethod, a property prop1(que é somente leitura) e a property prop2(que também podem ser configuradas), bem como uma função chamada do_stuff. Qualquer que seja a classe criada agora Base, terá que implementar tudo isso para métodos / propriedades. Observe que, para um método ser abstrato, são necessários dois decoradores - classmethode abstrato property.

Agora poderíamos criar uma classe Acomo esta:

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

Todos os métodos / propriedades necessários são implementados e podemos - é claro - também adicionar funções adicionais que não fazem parte Base(aqui i_am_not_abstract:).

Agora podemos fazer:

a1 = A('dummy', 10, 'stuff')
a2 = A.from_dict({'name': 'from_d', 'val1': 20, 'val2': 'stuff'})

a1.prop1
# prints 10

a1.prop2
# prints 'stuff'

Como desejado, não podemos definir prop1:

a.prop1 = 100

retornará

AttributeError: não é possível definir o atributo

Também nosso from_dictmétodo funciona bem:

a2.prop1
# prints 20

Se agora definimos uma segunda classe Bcomo esta:

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

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

e tentou instanciar um objeto como este:

b = B('iwillfail')

receberemos um erro

TypeError: Não é possível instanciar a classe abstrata B com métodos abstratos do_stuff, from_dict, prop2

listando todas as coisas definidas nas Basequais não implementamos B.

também isso funciona e é simples:

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

Você também pode aproveitar o método __new__ para sua vantagem. Você acabou de se esquecer de algo. O método __new__ sempre retorna o novo objeto, portanto você deve retornar o novo método da superclasse. Faça o seguinte.

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)

Ao usar o novo método, você deve retornar o objeto, não a palavra-chave None. Foi tudo o que você perdeu.

Acho a resposta aceita, e todas as outras estranhas, uma vez que passam selfpara uma aula abstrata. Uma classe abstrata não é instanciada, portanto não pode ter a self.

Então tente isso, funciona.

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

No seu snippet de código, você também pode resolver isso fornecendo uma implementação para o __new__método na subclasse, da mesma forma:

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

Mas isso é um truque e eu o aconselho a não ser que você saiba o que está fazendo. Em quase todos os casos, recomendo que você use o abcmódulo, sugerido por outras pessoas antes de mim.

Além disso, quando você cria uma nova classe (base), torná-lo subclasse object, como este: class MyBaseClass(object):. Não sei mais se isso é significativo, mas ajuda a manter a consistência do estilo no seu código

Apenas uma rápida adição à resposta antiga da @ TimGilbert ... você pode fazer com que o método init () da sua classe base abstrata lance uma exceção e isso impediria que ela fosse instanciada, não?

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