A maneira antiga (pré - PEP 3119 ) de fazer isto é apenas para raise NotImplementedError na classe abstracta quando um método abstracto é 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): [...]

Isto não tem as mesmas propriedades que usar o módulo abc. Você ainda pode instanciar a classe base abstrata em si, e você não vai encontrar o seu erro até que você chame o método abstrato em tempo de execução.

Este vai trabalhar no 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

No método __init__ da classe que você quer ser uma classe abstrata, você pode verificar o "tipo" de si mesmo. Se o tipo de si mesmo é a classe base, então o chamador está tentando instanciar a classe base, então levantar 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

Irv

A maioria das respostas anteriores estavam correctas, mas aqui está a resposta e o exemplo para o Python 3.7. Sim, você pode criar classe abstrata e método. Assim como um lembrete às vezes uma classe deve definir um método que logicamente pertence a uma classe, mas essa classe não pode especificar como implementar o método. Por exemplo, nas classes de pais e bebês abaixo que ambos comem, mas a implementação será diferente para cada um, porque bebês e pais comem diferentes tipos de alimentos e o número de vezes eles comem é diferente. Então, o método de comer em sub classes sobrepõe-se à AbstractClass.comer.

AbstractClass, come metho

import abc
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 only3 times or more each day

SIM, pode criar classes abstractas em python com o módulo abc (abstract base classes).

Este site vai ajudá-lo com ele: http://docs.python.org/2/library/abc.html

Isto também 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()

Sim você pode, usando o . abc - Módulo de Classes de base Abstractas, aqui está um exemplo:

Python3. 6

# importing abstract base classes module
import abc

class GetterSetter(abc.ABC):
    '''
    ABSTRACT BASE CLASSES:

    -  An abstract base class is a kind of 'model' for other classes to be defined.
        - It is not designed to construct instances, but can be subclassed by regular classes

    - Abstract classes can define interface, or methods that must be implemented by its subclasses.

    '''


    # Abstract classes are not designed to be instantiated, only to be subclassed

    #  decorator for abstract class
    @abc.abstractmethod
    def set_val(self, input):
        """set the value in the instance"""
        return

    @abc.abstractmethod
    def get_val(self):
        """Get and return a value from the instance..."""
        return

# Inheriting from the above abstract class
class MyClass(GetterSetter):

    # methods overriding in the GetterSetter
    def set_val(self, input):
        self.val = input

    def get_val(self):
        return self.val


# Instantiate
x = MyClass()
print(x) # prints the instance <__main__.MyClass object at 0x10218ee48>
x = GetterSetter() #throws error, abstract classes can't be instantiated

Python2.x

import abc

class GetterSetter(object):
    # meta class is used to define other classes
    __metaclass__ = abc.ABCMeta


    #  decorator for abstract class
    @abc.abstractmethod
    def set_val(self, input):
        """set the value in the instance"""
        return

    @abc.abstractmethod
    def get_val(self):
        """Get and return a value from the instance..."""
        return

# Inheriting from the above abstract class
class MyClass(GetterSetter):

    # methods overriding in the GetterSetter
    def set_val(self, input):
        self.val = input

    def get_val(self):
        return self.val


# Instantiate
x = GetterSetter()
print(x)
x = GetterSetter() #throws error, abstract classes can't be instantiated

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

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

Também quando você criar uma nova classe (base), faça-a subclasse object, Assim: class MyBaseClass(object):. Já não sei se é assim tão importante, mas ... ajuda a manter a consistência do estilo no seu código

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