Herança em Classes em Python

Posts Relacionados:

Métodos úteis de strings em Python

Operadores de atribuição em Python

Você sabe alinhar textos com Python?

09.10.24

Em programação orientada a objetos, herança é a capacidade de uma classe de derivar ou herdar as propriedades de outra classe. Aprenda como usar herança em classes em Python.

Receba nossa newsletter

Herança em Classes em Python

Se você já usou frameworks como Kivy ou Django, certamente já se deparou com herança em classes em Python. Este é um dos principais conceitos em linguagens de programação orientada a objetos. Devido a sua importância, dominá-lo é fundamental. Neste post, exploraremos esse conceito através de seus aspectos mais básicos.

O que é herança em linguagens de programação orientada a objetos?

Herança é a capacidade de uma classe de derivar ou herdar as propriedades de outra classe. Ou seja, ela possibilita que uma classe herde atributos e comportamentos de outra classe sem precisar implementá-los novamente.

Especialmente em Python, a herança permite criar relações hierárquicas entre classes. Esta hierarquia é fundamental para garantir a reutilização de códigos através do estabelecimento de estruturas lógicas.

Herança em código: o mais básico

Para criar uma classe filha que herda de uma classe pai, a estrutura básica é mostrada abaixo:

				
					
class ClassePai:
    # Atributos e métodos da classe pai

class ClasseFilha(ClassePai):
    # Atributos e métodos de classe filha

No trecho acima, para a herança passar da classe pai para a classe filha, a classe pai é explicitamente indicada na definição da classe filha. Com isso, a classe filha herda automaticamente os atributos e métodos da classe pai.

Herança em código para classes em Python

Veja um exemplo mais concreto abaixo:

				
					class Pessoa:
    def __init__(self, primeiro_nome, sobrenome):
        self.primeiro_nome = primeiro_nome
        self.sobrenome = sobrenome

    def nome_completo(self):
        nome = f"{self.primeiro_nome} {self.sobrenome}"
        return nome

class Cliente(Pessoa):
    def nome_do_cliente(self):
        info_cliente = {
            'nome': self.nome_completo(),
        }
        return info_cliente

cliente1 = Cliente('Maria', 'da Silva')
print(cliente1.nome_do_cliente()) # resultado: {'nome': 'Maria da Silva'}

Neste exemplo, definimos duas classes. A classe Pessoa possui dois atributos (primeiro_nome, sobrenome) e um método (nome_completo()). Ela é a classe pai ou superclasse. A classe filha (subclasse) herda da classe pai. No exemplo acima, ela possui apenas um método próprio que retorna o nome do cliente. Porem, todos os elementos que ela usa nesse método são herdados da classe pai. Ou seja, para retornar o nome do cliente, a classe filha usa o método nome_completo() da classe pai que, por sua vez, possui dois atributos (primeiro_nome e sobrenome). Ambos são atributos da classe Pessoa. Mas, como a classe Cliente herda da classe Pessoa, eles também são atributos seus.

Como a classe filha precisa dos argumentos da classe pai, a criação de suas instâncias requer que essas informações sejam fornecidas (linhas 17 no exemplo acima).

Invocando o método init() da classe pai

No exemplo anterior, a classe filha não possui atributos próprios. Consequentemente, ela foi definida sem o construtor __init__(). Mas, quando criamos uma classe filha que herda de uma classe pai em Python, geralmente é recomendável invocar o método __init__() da classe pai ao inicializar a classe filha. Esse procedimento não é estritamente necessário sempre.

Se a classe filha precisar adicionar novos atributos ou personalizações, mas ainda garantir que qualquer configuração ou inicialização feita na classe pai, o __init__() do pai deve ser invocado.

Para invocar o método __init__() da classe pai, ele pode ser definido explicitamente como ilustrado abaixo (linha 13):

				
					class Pessoa:
    def __init__(self, primeiro_nome, sobrenome):
        self.primeiro_nome = primeiro_nome
        self.sobrenome = sobrenome

    def nome_completo(self):
        nome = f"{self.primeiro_nome} {self.sobrenome}"
        return nome


class Cliente(Pessoa):
    def __init__(self, primeiro_nome, sobrenome):
        Pessoa.__init__(self, primeiro_nome, sobrenome)

    def nome_do_cliente(self):
        info_cliente = {
            'nome': self.nome_completo(),
        }
        return info_cliente

Método super()

Outra forma de invocar o __init__() da classe pai é com o método super(). Essa é a forma mais recomendável para invocar o construtor __init__() da classe pai. A sintaxe para isso é mostrada abaixo:

				
					
class ClasseFilha(ClassePai):
    def __init__(self, argumento_pai, argumento_filha):
        super().__init__(argumento_pai)
        self.argumento_filha = argumento_filha

Abaixo, mostramos um caso ilustrativo de como usar o método super().

				
					class Pessoa:
    def __init__(self, primeiro_nome, sobrenome):
        self.primeiro_nome = primeiro_nome
        self.sobrenome = sobrenome

    def nome_completo(self):
        nome = f"{self.primeiro_nome} {self.sobrenome}"
        return nome

class Funcionario(Pessoa):
    def __init__(self, primeiro_nome, sobrenome, n_id, cargo):
        super().__init__(primeiro_nome, sobrenome)
        self.n_id = n_id
        self.cargo = cargo

    def verifica_info_funcionario(self):
        info_foncionario = {
            'nome': self.nome_completo(),
            'cargo': self.cargo,
            'n_id': self.n_id,
        }
        return info_foncionario

funcionario1 = Funcionario('Maria', 'da Silva', 12345, 'gerente')
print(funcionario1.verifica_info_funcionario()) # resultado: {'nome': 'Maria da Silva', 'cargo': 'gerente', 'n_id': 12345}

Neste trecho, definimos duas classes. A classe pai é denominada Pessoa, a classe filha se chama Funcionario. Além dos atributos do pai, a classe filha tem dois atributos próprios (n_id e cargo). Para inicializar todos os seus atributos, usamos o método super() no construtor __init__() (linhas 11-14). Ele invoca os argumentos do pai antes dos argumentos da classe filha serem inicializados (linha 12).

O método super() não é uma exclusividade do Python. Em Python, assim como em outras linguagens orientadas a objetos, ele permite chamar métodos de uma superclasse (classe pai) em sua subclasse (classe filha). O principal caso de uso disso é estender a funcionalidade dos métodos e atributos herdados.