Herança Múltipla Python

Resumo : neste tutorial, você aprenderá sobre a herança múltipla do Python e como a resolução da ordem dos métodos funciona no Python.

Introdução à herança múltipla do Python.

Quando uma classe herda de uma única classe, você tem herança única . Python permite que uma classe herde de várias classes. Se uma classe herdar de duas ou mais classes, você terá herança múltipla.

Para estender múltiplas classes, você especifica as classes pai entre parênteses ()após o nome da classe filha assim:

class ChildClass(ParentClass1, ParentClass2, ParentClass3):
   passLinguagem de código:  Python  ( python )

A sintaxe para herança múltipla é semelhante a uma lista de parâmetros na definição de classe. Em vez de incluir uma classe pai entre parênteses, você inclui duas ou mais classes, separadas por vírgula.

Vamos dar um exemplo para entender como funciona a herança múltipla:

Primeiro, defina uma classe Carque possua o go()método:

class Car:
    def go(self):
        print('Going')Linguagem de código:  Python  ( python )

Segundo, defina uma classe Flyableque possua o fly()método:

class Flyable:
    def fly(self):
        print('Flying')Linguagem de código:  Python  ( python )

Terceiro, defina o FlyingCarque herda de ambas Caras Flyableclasses:

class FlyingCar(Flyable, Car):
    passLinguagem de código:  Python  ( python )

Como FlyingCarherda de classes Care Flyable, ele reutiliza os métodos dessas classes. Isso significa que você pode chamar os métodos go()e fly()em uma instância da FlyingCarclasse assim:

if __name__ == '__main__':
    fc = FlyingCar()
    fc.go()
    fc.fly()Linguagem de código:  Python  ( python )

Saída:

Going
FlyingLinguagem de código:  Python  ( python )

Ordem de resolução do método (MRO)

Quando as classes pai têm métodos com o mesmo nome e a classe filha chama o método, o Python usa a ordem de resolução do método (MRO) para procurar o método correto a ser chamado. Considere o seguinte exemplo:

Primeiro, adicione o start()método às classes Car, Flyablee FlyingCar. No start()método da FlyingCarclasse, chame o start()método de super():

class Car:
    def start(self):
        print('Start the Car')

    def go(self):
        print('Going')


class Flyable:
    def start(self):
        print('Start the Flyable object')

    def fly(self):
        print('Flying')


class FlyingCar(Flyable, Car):
    def start(self):
        super().start()Linguagem de código:  Python  ( python )

Segundo, crie uma instância da FlyingCarclasse e chame o start()método:

if __name__ == '__main__':
    car = FlyingCar()
    car.start()Linguagem de código:  Python  ( python )

Saída:

Start the Flyable objectLinguagem de código:  Python  ( python )

Como você pode ver claramente na saída, super().start()chama o start()método da Flyableclasse.

O seguinte mostra o __mro__da FlyingCarclasse:

print(FlyingCar.__mro__)Linguagem de código:  Python  ( python )

Saída:

(<class '__main__.FlyingCar'>, <class '__main__.Flyable'>, <class '__main__.Car'>, <class 'object'>)Linguagem de código:  Python  ( python )

Da esquerda para a direita, você verá FlyingCar, Flyable, Care object.

Observe que os objetos Care Flyableherdam implicitamente da objectclasse. Quando você chama o start()método do FlyingCarobjeto ‘, o Python usa o __mro__caminho de pesquisa da classe.

Como a Flyableclasse está próxima à FlyingCarclasse, super().start()chama o start()método da FlyingCarclasse.

Se você inverter a ordem das Flyableclasses Carna lista, elas __mro__mudarão de acordo. Por exemplo:

# Car, Flyable classes...


class FlyingCar(Car, Flyable):
    def start(self):
        super().start()


if __name__ == '__main__':
    car = FlyingCar()
    car.start()

    print(FlyingCar.__mro__)Linguagem de código:  Python  ( python )

Saída:

Start the Car
(<class '__main__.FlyingCar'>, <class '__main__.Car'>, <class '__main__.Flyable'>, <class 'object'>)Linguagem de código:  Python  ( python )

Neste exemplo, em vez disso, o método super().start()chama o start()método da Carclasse, com base em suas ordens na resolução da ordem do método.

Herança múltipla e super

Primeiro, adicione o __init__método à Carclasse:

class Car:
    def __init__(self, door, wheel):
        self.door = door
        self.wheel = wheel

    def start(self):
        print('Start the Car')

    def go(self):
        print('Going')Linguagem de código:  Python  ( python )

Segundo, adicione o __init__método à Flyableclasse:

class Flyable:
    def __init__(self, wing):
        self.wing = wing

    def start(self):
        print('Start the Flyable object')

    def fly(self):
        print('Flying')Linguagem de código:  Python  ( python )

As __init__classes Care Flyableaceitam um número diferente de parâmetros. Se a FlyingCarclasse herda das classes Care Flyable, seu __init__método precisa chamar o __init__método correto especificado na resolução da ordem __mro__do método da FlyingCarclasse.

Terceiro, adicione o __init__método à FlyingCarclasse:

class FlyingCar(Flyable, Car):
    def __init__(self, door, wheel, wing):
        super().__init__(wing=wing)
        self.door = door
        self.wheel = wheel

    def start(self):
        super().start()Linguagem de código:  Python  ( python )

A resolução da ordem do método da FlyingCarclasse é:

(<class '__main__.FlyingCar'>, <class '__main__.Flyable'>, <class '__main__.Car'>, <class 'object'>)Linguagem de código:  Python  ( python )

as super().__init__()chamadas __init__da FlyingCarclasse. Portanto, você precisa passar o wingargumento para o __init__método.

Como a FlyingCarclasse não pode acessar o __init__método da Carclasse, você precisa inicializar os atributos doore wheelindividualmente.

Resumo

• A herança múltipla do Python permite que uma classe herde de várias classes.
• A resolução da ordem do método define o caminho de pesquisa da classe para encontrar o método a ser chamado.