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):
pass
Linguagem 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 Car
que possua o go()
método:
class Car:
def go(self):
print('Going')
Linguagem de código: Python ( python )
Segundo, defina uma classe Flyable
que possua o fly()
método:
class Flyable:
def fly(self):
print('Flying')
Linguagem de código: Python ( python )
Terceiro, defina o FlyingCar
que herda de ambas Car
as Flyable
classes:
class FlyingCar(Flyable, Car):
pass
Linguagem de código: Python ( python )
Como FlyingCar
herda de classes Car
e 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 FlyingCar
classe assim:
if __name__ == '__main__':
fc = FlyingCar()
fc.go()
fc.fly()
Linguagem de código: Python ( python )
Saída:
Going
Flying
Linguagem 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
, Flyable
e FlyingCar
. No start()
método da FlyingCar
classe, 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 FlyingCar
classe e chame o start()
método:
if __name__ == '__main__':
car = FlyingCar()
car.start()
Linguagem de código: Python ( python )
Saída:
Start the Flyable object
Linguagem de código: Python ( python )
Como você pode ver claramente na saída, super().start()
chama o start()
método da Flyable
classe.
O seguinte mostra o __mro__
da FlyingCar
classe:
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
, Car
e object
.
Observe que os objetos Car
e Flyable
herdam implicitamente da object
classe. Quando você chama o start()
método do FlyingCar
objeto ‘, o Python usa o __mro__
caminho de pesquisa da classe.
Como a Flyable
classe está próxima à FlyingCar
classe, super().start()
chama o start()
método da FlyingCar
classe.
Se você inverter a ordem das Flyable
classes Car
na 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 Car
classe, 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 à Car
classe:
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 à Flyable
classe:
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 Car
e Flyable
aceitam um número diferente de parâmetros. Se a FlyingCar
classe herda das classes Car
e Flyable
, seu __init__
método precisa chamar o __init__
método correto especificado na resolução da ordem __mro__
do método da FlyingCar
classe.
Terceiro, adicione o __init__
método à FlyingCar
classe:
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 FlyingCar
classe é:
(<class '__main__.FlyingCar'>, <class '__main__.Flyable'>, <class '__main__.Car'>, <class 'object'>)
Linguagem de código: Python ( python )
as super().__init__()
chamadas __init__
da FlyingCar
classe. Portanto, você precisa passar o wing
argumento para o __init__
método.
Como a FlyingCar
classe não pode acessar o __init__
método da Car
classe, você precisa inicializar os atributos door
e wheel
individualmente.
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.