Herança de Python

Introdução

A herança é mais um conceito -chave na programação orientada a objetos e desempenha um papel vital na construção de classes. Permite que uma classe seja baseada em uma existente.

Quando você começou a escrever aulas de Python, você foi instruído a colocar "objeto" nos parênteses da definição de classe e não pensar muito nisso. Bem, agora é a hora de começar a pensar nisso.

"Objeto" é na verdade a classe base que todas as classes python herdam. Ele define um conjunto básico de funcionalidade que todas as classes Python deveriam ter. Ao herdar dele quando você cria uma nova classe, você garante que essa classe tenha essa funcionalidade básica.

Em resumo, a herança é uma boa maneira de categorizar aulas e garantir que você não se repete desnecessariamente.

O que é herança?

A herança existe no mundo real também. Os primeiros dois guias usaram um carro como exemplo de uma aula. Bem, e se você quiser tipos mais específicos de carros que compartilham esses princípios básicos de um carro? A herança pode ajudar.

Você pode começar com uma classe "carro" básica que possui todas as propriedades que todo carro compartilha. Tudo isso seria muito geral.

Depois de ter seu "carro", você pode criar novas classes e passar por eles "carro.”Todos eles terão as mesmas propriedades que a classe Base“ Car ”. Em seguida, você pode adicionar propriedades adicionais que desejar às aulas mais especializadas. Por exemplo, você pode ter "caminhão", "muscle car" e "SUV" aulas que todos herdam do "carro.”

Quando você pensa sobre isso em termos do mundo real, caminhões, muscle cars e SUVs têm as mesmas propriedades básicas que qualquer outro carro, mas também têm propriedades especializadas.

Você também pode se especializar ainda mais. Existem toneladas de diferentes tipos de caminhões. Portanto, você pode criar classes mais especializadas que herdam de “caminhão.”A vontade começa com tudo que se forma“ carro ”e tudo de“ caminhão.”

Usando herança em python

Tudo bem, então agora você pode tentar isso com algum código real. Configure uma aula básica de "carro" que herda de "Objeto.”Tente trabalhar com o exemplo abaixo.

Classe Car (objeto): def __init __ (self, make = 'ford', modelo = 'pinto', ano = '1971', milhagem = 253812, color = 'laranja'): self.__make = se faça.__model = modelo.__ ano = ano eu.__mileage = milhagem.__color = cor def move_forward (self, speed): print ("seu %s está avançando em %s" %(self.__model, velocidade)) def move_backward (self, speed): print ("movendo -se para trás em % s" % speed) classe Musclecar (carro): __hp = 300 def set_hp (self, hp): self.__hp = hp def get_hp (self): return self.__hp def drag_race (self, oponente): se (self.__hp> oponente.get_hp ()): retorne "você ganha!"Else: retornar" você perde!"MyNewCar = MuscleCar ('Ford', 'Mustang', '2016', 3000, 'Red') MyNewcar.set_hp (687) oponente = muscclecar ('ford', 'mustang', '2014', 6400, 'verde') oponente.set_hp (465) MyNewcar.move_forward ('25mph') impressão (MyNewcar.drag_race (oponente)) 

Observe que o MuscleCar Objetos foram capazes de usar o construtor e o Siga em frente Método da classe "carro", embora a classe de onde eles tenham sido instanciados não os tenha explicitamente.

Substituindo

Só porque uma classe herda de outra, você não está preso a toda a funcionalidade da classe pai. Você pode substituir partes da classe pai nas classes infantis. As mudanças aplicadas à classe infantil não se aplicarão à classe pai original, então você não precisa se preocupar em bagunçar outras classes.

No exemplo acima, o "Musclecar" tinha uma variável, __hp apenas flutuando lá sem como defini -lo na instanciação. Confira o mesmo exemplo, mas com o construtor substituído.

Classe Car (objeto): def __init __ (self, make = 'ford', modelo = 'pinto', ano = '1971', milhagem = 253812, color = 'laranja'): self.__make = se faça.__model = modelo.__ ano = ano eu.__mileage = milhagem.__color = cor def move_forward (self, speed): print ("seu %s está avançando em %s" %(self.__model, velocidade)) def move_backward (self, speed): print ("movendo -se para trás em % s" % speed) classe Musclecar (carro): def __init __ (self, make = 'ford', model = 'Mustang', ano = ano = ano = ano = '1965', milhagem = 54032, color = 'azul', hp = 325): self.__make = se faça.__model = modelo.__ ano = ano eu.__mileage = milhagem.__color = cor de si mesmo.__hp = hp def set_hp (self, hp): self.__hp = hp def get_hp (self): return self.__hp def drag_race (self, oponente): se (self.__hp> oponente.get_hp ()): retorne "você ganha!"Else: retornar" você perde!"MyNewCar = MuscleCar ('Ford', 'Mustang', '2016', 3000, 'Red', 687) oponente = MuscleCar () MyNewcar.move_forward ('25mph') impressão (MyNewcar.drag_race (oponente)) 

Há duas coisas para perceber. Primeiro, __hp se tornou auto.__hp e é incorporado ao construtor. Por causa disso, definir é muito mais fácil. Segundo, os valores padrão para um novo "Musclecar" foram alterados. Um pinto não é um carros muscular padrão muito bom, é?

Você pode fazer isso com qualquer variável ou método em uma subclasse ou classe infantil. Ele adiciona um grau adicional de flexibilidade e impede que você seja preso à funcionalidade do pai ou da super classe.

O super método

Às vezes, você precisa acessar os métodos encontrados na classe pai de dentro da classe infantil. Veja o exemplo anterior que substitui esse construtor. Muito desse código é redundante. Usando super() chamar o construtor da classe "carro" elimina essa redundância e contribui para uma classe mais simplificada.

super() Também pode ser usado apenas para acessar métodos regulares para uso em métodos de subclasse. O exemplo abaixo usado super() em ambos os sentidos.

Classe Car (objeto): def __init __ (self, make = 'ford', modelo = 'pinto', ano = '1971', milhagem = 253812, color = 'laranja'): self.__make = se faça.__model = modelo.__ ano = ano eu.__mileage = milhagem.__color = cor def set_make (self, make): self.__make = Make def get_make (self): retornar.__make def set_model (self, modelo): self.__model = modelo def get_model (self): retornar.__model def set_year (self, ano): self.__year = ano def Get_Year (self): retornar.__ ano def set_mileage (self, quilometragem): self.__mileage = milhagem def get_mileage (self): return self.__mileage def set_color (self, cor): self.__color = cor def get_color (self): retornar.__color def move_forward (self, speed): print ("seu %s está avançando em %s" %(self.__model, velocidade)) def move_backward (self, speed): print ("movendo -se para trás em % s" % speed) classe Musclecar (carro): def __init __ (self, make = 'ford', model = 'Mustang', ano = ano = ano = ano = '1965', milhagem = 54032, color = 'Blue', hp = 325): super ().__init __ (make, modelo, ano, quilometragem, cor).__hp = hp def set_hp (self, hp): self.__hp = hp def get_hp (self): return self.__hp def drag_race (self, oponente): se (self.__hp> oponente.get_hp ()): retorne "você ganha!"Else: retornar" você perde!"Def Trade_Up (self, ano, cor): super ().set_year (ano) super ().set_color (color) super ().set_mileage (0) myNewcar = muscclecar ('ford', 'mustang', '2016', 3000, 'vermelho', 687) oponente = muscclecar () mynewcar.move_forward ('25mph') impressão (MyNewcar.drag_race (oponente)) MyNewcar.Trade_Up ('2017', 'Black') Print ("Meu novo Muscle Car é %s e tem %D milhas" %(MyNewcar.get_year (), MyNewcar.get_color (), MyNewcar.get_mileage ())) 

Veja a maneira como o trade_up Método utiliza super() Para acessar e chamar esses métodos de setter da classe pai.

Pensamentos finais

A herança permite que você use classes como modelos para classes mais especializadas. Você pode criar aulas em uma estrutura que começa a se parecer com uma árvore genealógica, com os membros "mais velhos" e mais gerais transmitindo características para os membros mais especializados "mais jovens".

Grande parte da programação orientada a objetos está reduzindo a quantidade de código que é escrita e impedindo o máximo de código possível de ser reescrito. A herança tem um grande papel em tornar isso possível.

Exercícios

1. Crie uma classe básica que herda da aula de "carro".
2. Instancie sua nova classe e ligue para um dos métodos de “Carro.”
3. Crie um novo método em sua aula de crianças.
4. Ligue para o seu novo método.
5. Usar super() Para adicionar variáveis ​​ao construtor da sua classe de criança.
6. Criar um método usando super() Para acessar os métodos da classe pai.
7. Ligue para o seu novo método que usa super().

Tutoriais do Linux relacionados:

• Coisas para instalar no Ubuntu 20.04
• Coisas para fazer depois de instalar o Ubuntu 20.04 fossa focal linux
• Coisas para instalar no Ubuntu 22.04
• Uma introdução à automação, ferramentas e técnicas do Linux
• Ubuntu 20.04 truques e coisas que você pode não saber
• Ubuntu 20.04 Guia
• Coisas para fazer depois de instalar o Ubuntu 22.04 Jellyfish…
• Como fazer bota dupla kali linux e windows 10
• Como construir um aplicativo Tknter usando um objeto orientado…
• Mint 20: Melhor que o Ubuntu e o Microsoft Windows?