Definir Classes e Objetos em Python

Introdução

Neste laboratório, você aprenderá os conceitos fundamentais de Programação Orientada a Objetos (POO - Object-Oriented Programming) em Python. Exploraremos como definir classes, que servem como modelos (blueprints) para a criação de objetos, e entenderemos a relação entre classes e objetos.

Você ganhará experiência prática criando e utilizando instâncias das classes que definir. O laboratório o guiará através da inicialização de objetos com o método __init__ para definir seu estado inicial e da personalização de sua representação em string usando o método __repr__ para melhor depuração (debugging) e legibilidade.

Definir uma Classe e Criar uma Instância

Nesta etapa, você aprenderá como definir uma classe básica e criar um objeto, ou instância, a partir dela.

Em Programação Orientada a Objetos, uma classe é um modelo (blueprint) para a criação de objetos. Ela define um conjunto de atributos (dados) e métodos (funções) que os objetos criados terão. Um objeto é uma instância de uma classe, uma entidade concreta construída a partir do modelo da classe.

Vamos começar criando uma classe simples chamada Dog.

Primeiro, abra o arquivo dog.py no explorador de arquivos no lado esquerdo do WebIDE. Este arquivo está atualmente vazio.

Agora, adicione o seguinte código a dog.py para definir a classe Dog, criar uma instância e utilizá-la:

## Define a simple Dog class
class Dog:
    ## Class attribute
    species = "Canis familiaris"

    ## Method
    def bark(self):
        print("Woof!")

## Create an instance (object) of the Dog class
my_dog = Dog()

## Access the class attribute using the instance
print(f"The species is: {my_dog.species}")

## Call the instance's method
print("The dog says:")
my_dog.bark()

Vamos analisar o código:

class Dog:: Esta linha define uma nova classe chamada Dog.
species = "Canis familiaris": Este é um atributo de classe (class attribute). Seu valor é compartilhado entre todas as instâncias da classe Dog.
def bark(self):: Isto define um método (method), que é uma função dentro de uma classe. O parâmetro self é uma referência à instância atual da classe e é usado para acessar variáveis que pertencem à classe.
my_dog = Dog(): Esta linha cria uma nova instância da classe Dog e a atribui à variável my_dog.
my_dog.species: Acessamos o atributo species do objeto my_dog usando a notação de ponto.
my_dog.bark(): Chamamos o método bark no objeto my_dog. O Python passa automaticamente o objeto my_dog como o argumento self para o método.

Salve o arquivo. Para executar seu script, abra um terminal no WebIDE e execute o seguinte comando:

python dog.py

Você deverá ver a seguinte saída, confirmando que seu objeto foi criado e seu atributo e método foram acessados corretamente.

The species is: Canis familiaris
The dog says:
Woof!

Inicializar Objetos com o Método `init`

Embora os atributos de classe sejam compartilhados por todas as instâncias, muitas vezes você deseja que cada instância tenha seus próprios dados exclusivos. O método __init__ é um método especial em classes Python que funciona como um construtor. Ele é chamado automaticamente quando você cria uma nova instância, permitindo que você inicialize seus atributos exclusivos.

Vamos modificar a classe Dog para dar a cada cachorro um nome e raça únicos.

Abra o arquivo dog.py novamente e substitua seu conteúdo pelo código a seguir:

## Define a Dog class with an __init__ method
class Dog:
    ## Class attribute
    species = "Canis familiaris"

    ## The __init__ method (constructor)
    def __init__(self, name, breed):
        ## Instance attributes
        self.name = name
        self.breed = breed

    ## Method
    def bark(self):
        print("Woof!")

## Create instances with unique attributes
dog1 = Dog("Buddy", "Golden Retriever")
dog2 = Dog("Lucy", "Labrador")

## Access the instance attributes
print(f"{dog1.name} is a {dog1.breed}.")
print(f"{dog2.name} is a {dog2.breed}.")

## The class attribute is still shared
print(f"Both are of the species: {dog1.species}")

Veja o que mudou:

def __init__(self, name, breed):: Definimos o método __init__. Ele recebe self, name e breed como argumentos.
self.name = name e self.breed = breed: Estas linhas criam atributos de instância (instance attributes). Eles são exclusivos para cada objeto Dog. A palavra-chave self anexa esses atributos à instância específica que está sendo criada.
dog1 = Dog("Buddy", "Golden Retriever"): Ao criar uma instância, agora passamos argumentos para name e breed. Estes são passados automaticamente para o método __init__.

Salve o arquivo e execute-o a partir do terminal:

python dog.py

A saída mostra que cada objeto cachorro tem seu próprio nome e raça, enquanto ainda compartilha o atributo de classe species.

Buddy is a Golden Retriever.
Lucy is a Labrador.
Both are of the species: Canis familiaris

Personalizar a Representação do Objeto com `repr`

Quando você tenta imprimir um objeto diretamente, o Python exibe uma representação padrão que inclui a classe do objeto e seu endereço de memória, o que não é muito útil. Você pode fornecer uma representação em string mais descritiva e amigável ao desenvolvedor definindo o método especial __repr__.

Vamos adicionar um método __repr__ à nossa classe Dog.

Abra dog.py e substitua seu conteúdo pela versão final do nosso código:

## Define a Dog class with __init__ and __repr__ methods
class Dog:
    ## Class attribute
    species = "Canis familiaris"

    ## The __init__ method (constructor)
    def __init__(self, name, breed):
        self.name = name
        self.breed = breed

    ## The __repr__ method for a developer-friendly representation
    def __repr__(self):
        return f"Dog(name='{self.name}', breed='{self.breed}')"

    ## Method
    def bark(self):
        print("Woof!")

## Create an instance
my_dog = Dog("Buddy", "Golden Retriever")

## Print the object directly
print(my_dog)

A adição chave é:

def __repr__(self):: Isto define o método de representação.
return f"Dog(name='{self.name}', breed='{self.breed}')": Este método deve retornar uma string. Uma boa prática é fazer com que a string se pareça com uma expressão Python válida que poderia ser usada para recriar o objeto com o mesmo estado.

Salve o arquivo e execute o script pela última vez:

python dog.py

Em vez de um endereço de memória, a saída é agora a string clara e informativa retornada pelo seu método __repr__. Isso é extremamente útil para depuração (debugging).

Dog(name='Buddy', breed='Golden Retriever')

Resumo

Neste laboratório, você aprendeu os conceitos básicos de Programação Orientada a Objetos (POO) em Python. Você começou definindo uma classe simples e criando uma instância dela, aprendendo a usar atributos de classe e métodos. Em seguida, você aprimorou sua classe adicionando o método __init__ para inicializar cada objeto com atributos de instância exclusivos. Por fim, você personalizou a representação em string de seus objetos implementando o método __repr__, o que melhora muito a clareza e a capacidade de depuração (debuggability) do seu código. Esses conceitos são a base para construir aplicações mais complexas e organizadas em Python.