Pular para o conteúdo
CodeMDD.io | Coding Tutorials

Como usar o construtor da classe em Python?

[

Python Class Constructors: Control Your Object Instantiation

Os construtores de classe em Python são uma parte fundamental da programação orientada a objetos. Eles permitem que você crie e inicialize corretamente objetos de uma determinada classe, tornando esses objetos prontos para uso. Os construtores de classe acionam internamente o processo de instanciação do Python, que passa por duas etapas principais: criação da instância e inicialização da instância.

Se você deseja se aprofundar em como o Python constrói internamente objetos e aprender a personalizar o processo, este tutorial é para você.

Neste tutorial, você vai:

  • Entender o processo interno de instanciação do Python
  • Personalizar a inicialização do objeto usando .__init__()
  • Ajustar a criação do objeto substituindo .__new__()

Com esse conhecimento, você poderá ajustar a criação e inicialização de objetos em suas classes personalizadas em Python, o que lhe dará controle sobre o processo de instanciação em um nível mais avançado.

Construtores de Classe em Python e o Processo de Instanciação

Uma vez que você tenha uma classe para trabalhar, você pode começar a criar novas instâncias ou objetos dessa classe, que é uma forma eficiente de reutilizar funcionalidades em seu código.

Criar e inicializar objetos de uma determinada classe é uma etapa fundamental na programação orientada a objetos. Essa etapa é frequentemente referida como construção do objeto ou instantiação. A ferramenta responsável por executar esse processo de instanciação é comumente conhecida como um construtor de classe.

Em Python, o construtor de classe é um método especial chamado .__init__(). O construtor de classe é executado automaticamente quando você cria uma nova instância da classe e é responsável por inicializar os atributos do objeto.

Conhecendo os Construtores de Classe do Python

Em Python, os construtores de classe são definidos por meio de um método especial chamado .__init__(). Este método é executado automaticamente quando uma nova instância da classe é criada.

O construtor de classe é usado para inicializar os atributos do objeto. Os atributos são características dos objetos que podem armazenar dados diferentes. Por exemplo, em uma classe Pessoa, você pode ter o atributo nome que armazena o nome de uma pessoa e o atributo idade que armazena a idade.

Quando você cria um novo objeto da classe Pessoa, o construtor de classe será chamado automaticamente e poderá ter argumentos que definem os valores iniciais dos atributos, como o nome e a idade da pessoa.

Aqui está um exemplo de uma classe Pessoa com um construtor de classe:

class Pessoa:
    def __init__(self, nome, idade):
        self.nome = nome
        self.idade = idade

Neste exemplo, o construtor de classe .__init__() tem dois parâmetros: nome e idade. Quando você cria um novo objeto da classe Pessoa, você precisa fornecer os argumentos correspondentes para esses parâmetros.

Por exemplo:

p = Pessoa("João", 30)
print(p.nome)  # Saída: João
print(p.idade)  # Saída: 30

Neste código, a instância p da classe Pessoa é criada com o nome “João” e a idade 30. O construtor de classe atribui esses valores aos atributos nome e idade da instância.

Você pode definir quantos atributos forem necessários no construtor de classe, de acordo com a lógica e as necessidades do seu código.

Entendendo o Processo de Instanciação do Python

O construtor de classe em Python está intimamente ligado ao processo de instanciação de objetos. Este é o processo pelo qual uma nova instância de uma classe é criada e inicializada.

Quando você cria um objeto de uma determinada classe em Python, o processo de instanciação passa por duas etapas principais: criação da instância e inicialização da instância.

A criação da instância é a etapa em que o objeto é realmente criado na memória. Isso envolve a alocação de espaço na memória para armazenar o objeto e a configuração de seu estado inicial.

A inicialização da instância é a etapa em que os atributos do objeto são definidos. Isso geralmente envolve a atribuição de valores iniciais aos atributos com base nos argumentos fornecidos ao construtor da classe.

Os construtores de classe em Python estão diretamente envolvidos na etapa de inicialização da instância. Eles são responsáveis por receber os argumentos necessários e atribuir os valores correspondentes aos atributos do objeto.

Aqui está um exemplo do processo de instanciação de objetos em Python:

class Pessoa:
    def __init__(self, nome, idade):
        self.nome = nome
        self.idade = idade


p = Pessoa("João", 30)

Neste exemplo, a classe Pessoa possui um construtor de classe .__init__() que recebe os argumentos nome e idade. Quando você cria uma nova instância da classe Pessoa passando “João” e 30 como argumentos, o objeto p é criado na memória e os atributos nome e idade são definidos com os valores correspondentes.

Entender o processo de instanciação é importante para trabalhar com construtores de classe em Python. Isso permitirá que você crie e inicialize corretamente os objetos de suas classes, tornando-os prontos para uso em seu código.

Inicialização de Objetos com .init()

O construtor de classe em Python, .__init__(), é um método especial que é executado automaticamente quando você cria uma nova instância da classe. Ele é responsável por inicializar os atributos do objeto.

Fornecendo Inicializadores de Objetos Personalizados

Quando você cria uma nova instância de uma classe em Python, o construtor de classe é chamado automaticamente e pode executar um código específico para inicializar os atributos do objeto.

Os construtores de classe podem receber argumentos que são usados para definir os valores iniciais dos atributos. Isso permite que você crie objetos personalizados e forneça valores diferentes para os atributos de cada instância.

Aqui está um exemplo de uma classe Pessoa que possui um construtor de classe .__init__() com argumentos personalizados:

class Pessoa:
    def __init__(self, nome, idade):
        self.nome = nome
        self.idade = idade


p1 = Pessoa("João", 30)
p2 = Pessoa("Maria", 25)


print(p1.nome)  # Saída: João
print(p1.idade)  # Saída: 30
print(p2.nome)  # Saída: Maria
print(p2.idade)  # Saída: 25

Neste exemplo, a classe Pessoa possui um construtor de classe com dois parâmetros: nome e idade. Quando você cria as instâncias p1 e p2 da classe Pessoa, você fornece valores diferentes para esses atributos.

No final, cada instância terá seus próprios valores de nome e idade, tornando-as objetos independentes.

Construindo Inicializadores de Objetos Flexíveis

Os construtores de classe em Python podem ser personalizados para aceitar um número variável de argumentos. Isso permite que você construa inicializadores de objetos mais flexíveis, capazes de lidar com diferentes cenários e requisitos.

Para criar um construtor de classe com um número variável de argumentos, você pode usar a sintaxe *args para capturar um número arbitrário de argumentos posicionais, ou **kwargs para capturar um número arbitrário de argumentos de palavra-chave.

Veja um exemplo de uma classe Pessoa com um construtor de classe mais flexível:

class Pessoa:
    def __init__(self, *args, **kwargs):
        if args:
            self.nome = args[0]
        else:
            self.nome = kwargs.get("nome", "John Doe")


        self.idade = kwargs.get("idade", 0)


p1 = Pessoa("João", idade=30)
p2 = Pessoa(nome="Maria", idade=25)
p3 = Pessoa()


print(p1.nome)  # Saída: João
print(p1.idade)  # Saída: 30
print(p2.nome)  # Saída: Maria
print(p2.idade)  # Saída: 25
print(p3.nome)  # Saída: John Doe
print(p3.idade)  # Saída: 0

Neste exemplo, o construtor de classe .__init__() aceita um número variável de argumentos posicionais *args e argumentos de palavra-chave **kwargs.

O código dentro do construtor verifica se existem argumentos posicionais e usa o primeiro argumento como o valor do atributo nome. Se não houver argumentos posicionais, ele verifica se o argumento de palavra-chave nome está presente em kwargs e usa o valor correspondente.

O atributo idade é definido com o valor do argumento de palavra-chave idade em kwargs ou com o valor padrão 0 se não houver argumento correspondente.

Isso permite que você crie instâncias da classe Pessoa fornecendo diferentes combinações de argumentos, tornando o construtor de classe mais flexível.

Criação de Objetos com .new()

Como mencionado anteriormente, o construtor de classe em Python é implementado por meio do método especial .__init__(). Isso ocorre porque o construtor de classe é responsável por inicializar os atributos do objeto após sua criação.

Mas e se você quiser ter controle total sobre a criação do objeto e personalizar a lógica de criação? É aí que o método especial .__new__() entra em ação.

O método .__new__() é o primeiro método a ser chamado durante o processo de instanciação de objetos em Python. Ele é responsável pela criação do objeto e retorna o objeto criado.

O método .__new__() é chamado antes do método .__init__() e permite que você faça customizações avançadas no processo de criação de objetos.

Fornecendo Criadores de Objetos Personalizados

O método .__new__() é usado para criar e retornar uma nova instância da classe. Ele recebe como argumento a própria classe (cls) e retorna uma nova instância.

Aqui está um exemplo de uma classe Pessoa com um método .__new__() personalizado:

class Pessoa:
    def __new__(cls, *args, **kwargs):
        print("Método __new__() chamado")
        return super().__new__(cls)


    def __init__(self, nome, idade):
        print("Método __init__() chamado")
        self.nome = nome
        self.idade = idade


p = Pessoa("João", 30)

Neste exemplo, a classe Pessoa possui um método .__new__() personalizado que imprime uma mensagem na tela e retorna uma nova instância da classe usando super().__new__(cls).

O método .__init__() também está presente e é responsável por inicializar os atributos do objeto, assim como no exemplo anterior.

Quando você cria uma nova instância da classe Pessoa, os métodos .__new__() e .__init__() são chamados nesta ordem:

  • O método .__new__() é chamado primeiro e cria uma nova instância da classe.
  • O método .__init__() é chamado em seguida e inicializa os atributos do objeto.

Note que no exemplo acima o método .__new__() não faz nenhuma personalização avançada na criação do objeto. No entanto, esse método pode ser usado para executar lógica adicional de criação ou retornar instâncias de classes diferentes.

Substituindo Tipos de Dados Imutáveis

Outra utilidade do método .__new__() é a possibilidade de substituir tipos de dados imutáveis em Python. Um caso comum em que isso pode ser útil é quando você precisa criar um novo tipo de sequência com comportamento personalizado.

Pense em uma classe MinhaLista, que é uma alternativa personalizada para o tipo de lista embutido do Python. Você pode criar uma subclasse do tipo de lista embutido e substituir o método .__new__() para retornar instâncias de sua própria classe em vez do tipo de lista embutido.

Aqui está um exemplo de uma classe MinhaLista com um método .__new__() que substitui o tipo de lista embutido:

class MinhaLista(list):
    def __new__(cls, *args, **kwargs):
        return super().__new__(cls, *args, **kwargs)


    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)


ml = MinhaLista([1, 2, 3])


print(ml)  # Saída: [1, 2, 3]
print(type(ml))  # Saída: <class '__main__.MinhaLista'>

Neste exemplo, a classe MinhaLista é uma subclasse do tipo de lista embutido do Python. Ela possui um método .__new__() que retorna instâncias de sua própria classe.

Ao criar uma nova instância da classe MinhaLista passando uma lista [1, 2, 3] como argumento, você obtém uma nova instância de MinhaLista que comporta-se como uma lista, mas é do tipo MinhaLista, como comprovado pela saída type(ml).

Isso ilustra como o método .__new__() permite que você substitua tipos de dados imutáveis em Python e forneça comportamentos personalizados em suas classes.

Retornando Instâncias de uma Classe Diferente

O método .__new__() também pode ser usado para criar e retornar instâncias de uma classe diferente da classe atual. Isso oferece uma maneira avançada de modificar o processo de criação de objetos em Python.

Imagine uma classe Carro e uma subclasse CarroEsportivo que representa um tipo especializado de carro. Você pode usar o método .__new__() para criar instâncias de CarroEsportivo ao invés de Carro, mesmo ao usar o construtor de Carro.

Aqui está um exemplo dessa situação:

class Carro:
    def __new__(cls, *args, **kwargs):
        if "tipo" in kwargs and kwargs["tipo"] == "esportivo":
            cls = CarroEsportivo
        return super().__new__(cls)


    def __init__(self, marca, modelo):
        self.marca = marca
        self.modelo = modelo


class CarroEsportivo(Carro):
    def __init__(self, marca, modelo):
        super().__init__(marca, modelo)
        self.velocidade_maxima = 200


c1 = Carro("Fiat", "Uno")
c2 = Carro("Ferrari", "488 GTB", tipo="esportivo")  # Instância de CarroEsportivo


print(type(c1))  # Saída: <class '__main__.Carro'>
print(type(c2))  # Saída: <class '__main__.CarroEsportivo'>

Neste exemplo, a classe Carro possui um método .__new__() que verifica se o argumento “tipo” com valor “esportivo” foi passado. Em caso positivo, a classe é alterada para CarroEsportivo.

Quando você cria a instância c1 usando Carro("Fiat", "Uno"), a classe Carro é mantida e o objeto é criado normalmente. Você obtém uma instância de Carro, como comprovado pela saída type(c1).

Porém, quando você cria a instância c2 usando Carro("Ferrari", "488 GTB", tipo="esportivo"), o método .__new__() altera a classe para CarroEsportivo. O objeto é criado usando a classe CarroEsportivo e, assim, você obtém uma instância de CarroEsportivo, como comprovado pela saída type(c2).

Permitindo Apenas uma Única Instância em Suas Classes

Você também pode usar o método .__new__() para permitir apenas uma única instância de uma classe em Python. Isso é útil em situações em que você precisa garantir que não haja mais de uma instância de uma classe específica.

Por exemplo, vamos criar uma classe Singleton que permite apenas uma única instância:

class Singleton:
    _instance = None


    def __new__(cls, *args, **kwargs):
        if cls._instance is None:
            cls._instance = super().__new__(cls, *args, **kwargs)
        return cls._instance


s1 = Singleton()
s2 = Singleton()


print(s1 is s2)  # Saída: True

Neste exemplo, a classe Singleton possui uma variável de classe _instance que é inicialmente None. No método .__new__(), verificamos se _instance é None. Se for, chamamos o método .__new__() da superclasse para criar uma nova instância da classe. Em seguida, atribuímos essa nova instância a _instance.

Dessa forma, garantimos que a classe Singleton permita apenas uma única instância. Se você criar duas instâncias de Singleton, elas serão referências para a mesma instância, como comprovado pela saída s1 is s2 que retorna True.

Emulando Parcialmente collections.namedtuple

O método .__new__() também pode ser usado para emular parcialmente o comportamento da função collections.namedtuple() do módulo collections. Esta função é usada para criar classes de tuplas com campos nomeados.

Uma alternativa seria definir uma classe NamedTuple que aceita um número variável de argumentos posicionais e cria uma nova instância com os valores recebidos.

Aqui está um exemplo de uma classe NamedTuple que emula parcialmente collections.namedtuple():

class NamedTuple:
    def __new__(cls, *args):
        fields = args[0].split()
        values = args[1:]
        cls_name = "NamedTuple" + "".join(field.capitalize() for field in fields)
        attributes = {field: value for field, value in zip(fields, values)}
        return type(cls_name, (NamedTuple,), attributes)


nt = NamedTuple("nome idade cidade", "João 30 São Paulo")


print(nt.nome)  # Saída: João
print(nt.idade)  # Saída: 30
print(nt.cidade)  # Saída: São Paulo

Neste exemplo, a classe NamedTuple usa os argumentos posicionais para definir os campos e os valores de uma nova instância. Os campos são convertidos em uma string usando args[0].split() e os valores são obtidos de args[1:].

Em seguida, a classe cria um nome para a nova classe usando a string cls_name e define atributos para essa nova classe com base nos campos e valores fornecidos.

Finalmente, o método .__new__() retorna uma nova classe dinamicamente criada usando a função type().

Isso permite emular parcialmente o comportamento da função collections.namedtuple() e criar classes de tuplas com campos nomeados.

Conclusão

Os construtores de classe em Python são essenciais para o processo de construção e inicialização de objetos em programação orientada a objetos. Eles permitem que você crie e inicialize corretamente objetos de uma determinada classe, tornando-os prontos para uso em seu código.

Neste tutorial, você aprendeu sobre os construtores de classe em Python e sua relação com o processo de instanciação de objetos. Você viu como personalizar a inicialização de objetos usando o método .__init__() e como ajustar a criação de objetos substituindo o método .__new__().

Você também viu exemplos de construtores de classe personalizados, construtores flexíveis, criação de objetos personalizados com o método .__new__(), substituição de tipos de dados imutáveis e criação de instâncias de classes diferentes.

Com essas habilidades, você estará bem equipado para personalizar a criação e a inicialização de objetos em suas classes Python, permitindo que você tenha controle total sobre o processo de instanciação.