Explorando a Programação Orientada a Objetos em Python: O Método __init__
Está começando a se aventurar no design orientado a objetos com Python? Este é o momento ideal para dar os primeiros passos, explorando o método __init__ do Python.
Neste guia, vamos mergulhar nos fundamentos das classes e objetos em Python, com foco especial no método __init__.
Ao final deste tutorial, você terá as respostas para estas questões:
- O que são variáveis de instância, ou atributos de instância?
- De que forma o método init auxilia na inicialização dos atributos de instância?
- Como estabelecer valores padrão para os atributos?
- Como utilizar métodos de classe como construtores para criar objetos?
Vamos começar nossa jornada!
Classes e Objetos em Python
As classes são a espinha dorsal da programação orientada a objetos em Python. Elas nos permitem criar estruturas que agrupam dados e funcionalidades relacionadas, definindo atributos e métodos.
Uma vez que uma classe é definida, ela serve como um modelo para a criação de objetos (também chamados de instâncias).
Vamos a um exemplo prático! Criaremos uma classe chamada `Employee`. Cada objeto desta classe possuirá os seguintes atributos:
- `full_name`: o nome completo do empregado, no formato “primeiroNome ultimoNome”.
- `emp_id`: o identificador único do empregado.
- `departamento`: o departamento ao qual o empregado pertence.
- `experiencia`: o número de anos de experiência do empregado.
O que isso realmente significa? 🤔
Cada empregado será uma instância específica, ou um objeto, da classe `Employee`. Cada um desses objetos terá seu próprio valor para `full_name`, `emp_id`, `departamento` e `experiencia`.
Esses atributos também são conhecidos como variáveis de instância, e usaremos esses termos de forma intercambiável.
Em breve, adicionaremos atributos. Por ora, definiremos a classe `Employee` da seguinte forma:
class Employee:
pass
O uso de `pass` nos permite ter um espaço reservado, prevenindo erros durante a execução do script.
Mesmo que a versão atual da classe `Employee` não tenha muita utilidade, ela já é uma classe válida. Podemos, portanto, criar objetos desta classe:
employee_1 = Employee() print(employee_1) #Output: <__main__.Employee object at 0x00FEE7F0>
Também é possível adicionar atributos e inicializá-los com valores, como demonstrado abaixo:
employee_1.full_name="Amy Bell" employee_1.department="HR"
No entanto, essa forma de adicionar atributos de instância é ineficiente e propensa a erros. Além disso, não permite que a classe seja utilizada como um modelo para criação de objetos. É aqui que o método __init__ se torna essencial.
A Importância do Método __init__ em Classes Python
É fundamental que sejamos capazes de inicializar as variáveis de instância ao criar um objeto, e o método `__init__` é quem nos permite fazer isso. O método `__init__` é chamado toda vez que um novo objeto da classe é criado, com o objetivo de estabelecer os valores das variáveis de instância.
Se você já programou em uma linguagem como C++, notará que o método `__init__` se assemelha ao funcionamento de construtores.
Definindo o Método __init__
Vamos incluir o método `__init__` à classe `Employee`:
class Employee:
def __init__(self, full_name,emp_id,department,experience):
self.full_name = full_name
self.emp_id = emp_id
self.department = department
self.experience = experience
O parâmetro `self` faz referência à própria instância da classe. `self.atributo` inicializa o atributo de instância com o valor do lado direito da atribuição.
Agora, podemos criar objetos da seguinte maneira:
employee_2 = Employee('Bella Joy','M007','Marketing',3)
print(employee_2)
# Output: <__main__.Employee object at 0x017F88B0>
Ao imprimir os objetos `employee`, não obtemos nenhuma informação útil além da classe à qual pertencem. Vamos adicionar um método `__repr__`, que define uma string de representação para a classe:
def __repr__(self):
return f"{self.full_name},{self.emp_id} from {self.department} with {self.experience} years of experience."
Com a adição do `__repr__` à classe `Employee`, temos:
class Employee:
def __init__(self, full_name,emp_id,department,experience):
self.full_name = full_name
self.emp_id = emp_id
self.department = department
self.experience = experience
def __repr__(self):
return f"{self.full_name},{self.emp_id} from {self.department} with {self.experience} years of experience."
Agora, os objetos do empregado possuem uma string de representação útil:
print(employee_2) # Output: Bella Joy,M007 from Marketing with 3 years of experience.
Convenções Importantes
Antes de prosseguirmos, algumas observações:
- Utilizamos `self` como o primeiro parâmetro no método `__init__` para fazer referência à instância da classe. Utilizamos `self.nome_do_atributo` para inicializar os vários atributos. Usar `self` é uma convenção, mas você pode usar qualquer outro nome.
- Ao definir o método `__init__`, os nomes dos parâmetros que usamos nas definições devem coincidir com os nomes dos atributos. Isso melhora a legibilidade.
Como Definir Valores Padrão para Atributos
No exemplo que vimos até agora, todos os atributos são obrigatórios. Isso significa que a criação de um objeto só é bem-sucedida se passarmos os valores para todos os campos no construtor.
Tente criar um objeto da classe `Employee` sem passar o valor para o atributo `experience`:
employee_3 = Employee('Jake Lee','E001','Engineering')
Você verá o seguinte erro:
Traceback (most recent call last):
File "main.py", line 22, in <module>
employee_3 = Employee('Jake Lee','E001','Engineering')
TypeError: __init__() missing 1 required positional argument: 'experience'
Se desejar que determinados atributos sejam opcionais, pode definir valores padrão para eles ao definir o método `__init__`.
Aqui, fornecemos um valor padrão de 0 para o atributo `experience`:
class Employee:
def __init__(self, full_name,emp_id,department,experience=0):
self.full_name = full_name
self.emp_id = emp_id
self.department = department
self.experience = experience
def __repr__(self):
return f"{self.full_name},{self.emp_id} from {self.department} with {self.experience} years of experience."
O objeto `employee_3` é criado sem um valor para o atributo `experience`, e o valor padrão de 0 é usado neste caso.
employee_3 = Employee('Jake Lee','E001','Engineering')
print(employee_3.experience)
# Output: 0
Construtores de Classe Alternativos Usando Métodos de Classe
Até o momento, vimos como definir o método `__init__` e estabelecer valores padrão para os atributos quando necessário. Também sabemos que precisamos passar os valores para os atributos obrigatórios no construtor.
No entanto, em algumas situações, os valores dessas variáveis de instância (ou atributos) podem estar disponíveis em estruturas de dados diferentes, como tuplas, dicionários ou strings JSON.
O que fazer nesses casos?
Vamos considerar um exemplo. Suponha que tenhamos os valores de variáveis de instância em um dicionário Python:
dict_fanny = {'name':'Fanny Walker','id':'H203','dept':'HR','exp':2}
Podemos acessar o dicionário e obter todos os atributos da seguinte forma:
name = dict_fanny['name'] id = dict_fanny['id'] dept = dict_fanny['dept'] exp = dict_fanny['exp']
Após isso, podemos criar um objeto passando esses valores para o construtor da classe:
employee_4 = Employee(name, id, dept, exp) print(employee_4) # Output: Fanny Walker,H203 from HR with 2 years of experience.
Lembre-se: é necessário fazer isso para cada novo objeto que você criar. Essa abordagem é ineficiente e podemos fazer melhor. Mas como?
Em Python, podemos usar métodos de classe como construtores para criar objetos da classe. Para criar um método de classe, usamos o decorador `@classmethod`.
Vamos definir um método que analisa o dicionário, obtém os valores das variáveis de instância e os usa para criar objetos `Employee`.
@classmethod
def from_dict(cls,data_dict):
full_name = data_dict['name']
emp_id = data_dict['id']
department = data_dict['dept']
experience = data_dict['exp']
return cls(full_name, emp_id, department, experience)
Quando precisarmos criar objetos utilizando dados de um dicionário, podemos usar o método da classe `from_dict()`.
💡 Note o uso de `cls` no método da classe em vez de `self`. Da mesma forma que usamos `self` para fazer referência à instância, `cls` é usado para fazer referência à classe. Os métodos de classe são vinculados à classe e não aos objetos.
Portanto, quando chamamos o método de classe `from_dict()` para criar objetos, fazemos a chamada na classe `Employee`:
emp_dict = {'name':'Tia Bell','id':'S270','dept':'Sales','exp':3}
employee_5 = Employee.from_dict(emp_dict)
print(employee_5)
# Output: Tia Bell,S270 from Sales with 3 years of experience.
Agora, se tivermos um dicionário para cada um dos `n` funcionários, podemos usar o método de classe `from_dict()` como um construtor para criar objetos, sem ter que extrair os valores das variáveis de instância do dicionário.
📝 Uma observação sobre variáveis de classe
Aqui, definimos um método de classe que está vinculado à classe e não a instâncias individuais. De forma semelhante aos métodos de classe, também podemos ter variáveis de classe.
Assim como os métodos de classe, as variáveis de classe são vinculadas à classe e não a uma instância. Quando um atributo tem um valor fixo para todas as instâncias da classe, podemos defini-los como variáveis de classe.
Perguntas Frequentes
1. Por que precisamos do método `__init__` em Python?
O método `__init__` em uma definição de classe permite que inicializemos os atributos, ou variáveis de instância, para cada instância da classe. O método `__init__` é invocado sempre que uma nova instância da classe é criada.
2. É possível ter múltiplos métodos `__init__` em uma classe Python?
O objetivo de ter múltiplos métodos `__init__` em uma classe Python seria fornecer diversos construtores que criam objetos. No entanto, você não pode definir vários métodos `__init__`. Se você definir mais de um método `__init__`, a segunda implementação (mais recente) substituirá a primeira. Apesar disso, você pode usar o decorador `@classmethod` para definir métodos de classe que podem ser usados como construtores para instanciar objetos.
3. O que acontece se o método `__init__` não for definido em uma classe?
Se você não definir o método `__init__`, ainda poderá criar objetos. No entanto, você terá que adicionar as variáveis de instância manualmente e atribuir valores para cada uma delas. Você não poderá passar os valores para as variáveis de instância no construtor. Além de ser propenso a erros, isso anula o propósito de ter a classe como um modelo a partir do qual podemos criar objetos.
4. É possível ter valores padrão para argumentos no método `__init__`?
Sim, é possível definir valores padrão para um ou mais atributos ao definir o método `__init__`. Isso ajuda a tornar esses atributos opcionais no construtor. Os atributos assumem os valores padrão quando não passamos os valores para eles no construtor.
5. É possível modificar atributos fora do método `__init__`?
Sim, você sempre pode atualizar o valor de um atributo fora do método `__init__`. Você também pode adicionar dinamicamente novos atributos a uma instância depois que ela for criada.
Conclusão
Neste guia, aprendemos a usar o método `__init__` para inicializar os valores das variáveis de instância. Apesar de ser um processo direto, pode se tornar repetitivo, principalmente quando temos muitos atributos.
Se você estiver interessado, pode explorar o módulo `dataclasses`. No Python 3.7 e versões posteriores, você pode utilizar o módulo integrado de classes de dados para criar classes que armazenam dados. Além das implementações padrão do `__init__` e outros métodos de uso comum, elas vêm com muitos recursos interessantes para anotações de tipo, valores padrão complexos e otimização.
Em seguida, aprenda mais sobre `if __name__ == ‘__main__’` em Python.