Python classes: O que são e como usar classes em Python

Em Python, classes são es­tru­tu­ras fun­da­men­tais, pois funcionam como esquemas ou matrizes dessa linguagem de pro­gra­ma­ção. Graças às classes de Python, pro­gra­ma­do­res são capazes de escrever códigos reu­ti­li­zá­veis, que contém atributos e métodos.

O que são classes em Python?

Na linguagem de pro­gra­ma­ção Python, classes são in­ter­pre­ta­das de forma abstrata, por terem o poder de definir os atributos e os métodos que um objeto pode ter. Classes em Python servem como modelos para a criação de objetos concretos, que nada mais são do que ins­tân­cias de uma classe. Por exemplo, ao criarmos uma classe fictícia chamada carro, podemos conferir atributos a ela, como cor e marca, além de métodos __acelerar__ e __frear__.

Cada objeto de uma classe pode ter atributos com valores próprios, porém todos os objetos com­par­ti­lham os mesmos métodos e es­tru­tu­ras com­por­ta­men­tais das demais ins­tân­cias da mesma classe. De­ta­lhando ainda mais o nosso exemplo, dentro da classe carro, podemos es­ta­be­le­cer o objeto meu_carro, que tem a cor __vermelha__ e a marca __Toyota__. Contudo, os métodos da classe carro, __acelerar__ e __frear__, seguem sendo igual­mente válidos a todos os objetos, ou seja, a todas as ins­tân­cias.

Como criar classes em Python

Você pode definir classes em Python fazendo uso da palavra-chave class, como mostra o código a seguir:

class MyClass:
    # Constructor method called when creating an object
    def __init__(self, attribute1, attribute2):
        self.attribute1 = attribute1
        self.attribute2 = attribute2
    
    # Method defined within the class
    def my_method(self):
        return f"Attribute 1: {self.attribute1}, Attribute 2: {self.attribute2}"

Nesse código escrito em Python, pensamos em gerar uma classe chamada MyClass. Adi­ci­o­na­mos a ela um cons­tru­tor, __init__, que é utilizado para a criação de um objeto e para a ini­ci­a­li­za­ção de dois atributos: attribute1 e attribute2. O método my_method, por sua vez, é res­pon­sá­vel por retornar uma cadeia de ca­rac­te­res (string) formatada, contendo os valores desses atributos.

Para derivar um objeto a partir da classe que criamos, inserimos o nome da classe seguido de pa­rên­te­ses:

object1 = MyClass("Value 1", "Value 2")
# Calling a method of the object
result = object1.my_method()

Exemplos de uso de classes em Python

Em Python, classes são capazes de criar sistemas complexos e es­ta­be­le­cer relações entre as mais di­fe­ren­tes entidades. Observe, a seguir, situações variadas em que classes podem fazer a diferença, criando e modelando es­tru­tu­ras de forma mais or­ga­ni­zada e reu­ti­li­zá­vel.

Método __str()__

Dentro de classes em Python, o método __str__(), também conhecido como dunder, é con­si­de­rado um método especial. Ele pode ser usado para definir uma re­pre­sen­ta­ção legível de um objeto na forma de uma string. Você pode aplicar o método __str()__ di­re­ta­mente, passando uma instância da classe para a função str(), ou o com­bi­nando com a função print(). O exemplo abaixo explora as pos­si­bi­li­da­des:

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def __str__(self):
        return f"Name: {self.name}, Age: {self.age}"
person1 = Person("Alice", 30)
print(person1) # Output: Name: Alice, Age: 30

No nosso código fictício, o método __str__() foi usado para criar, dentro da classe Person, uma string formatada contendo o nome e a idade de uma pessoa. Assim que a função print(person1) é inserida, ela chama au­to­ma­ti­ca­mente o método __str__() do objeto person1, para que a res­pec­tiva string seja retornada por esse método.

Definir métodos de classes em Python

Na linguagem de pro­gra­ma­ção Python, você também pode definir métodos dentro de uma classe, para que eles executem operações nos res­pec­ti­vos objetos. Esses métodos podem ser chamados pelos objetos criados, como mostra o código abaixo:

class Rectangle:
    def __init__(self, length, width):
        self.length = length
        self.width = width
    
    def area(self):
        return self.length * self.width
    def perimeter(self):
        return 2 * (self.length + self.width)
# Creating an object of the class
my_rectangle = Rectangle(5, 10)
# Calling methods of the object
area = my_rectangle.area()
perimeter = my_rectangle.perimeter()
# Printing the calculated values
print("Area =", area) # Output: Area = 50
print("Perimeter =", perimeter) # Output: Perimeter = 30

Nesse código, desejamos criar a classe Rectangle, que deve conter dois métodos: area() e perimeter(). Esses métodos servem para calcular, res­pec­ti­va­mente, a área e o perímetro do retângulo com base nos valores com­pri­mento (length) e largura (width), que foram for­ne­ci­dos na ini­ci­a­li­za­ção do objeto. Nesse método de classe em Python, self faz re­fe­rên­cia ao objeto atual ao qual o método está sendo aplicado.

Observe que, como resultado, o objeto my_rectangle é criado, medindo 5 de com­pri­mento e 10 de largura. Em seguida, os métodos area() e perimeter() são aplicados a esse mesmo objeto, com o objetivo de calcular os demais valores.

Alterar pro­pri­e­da­des de objetos

O operador ponto . pode ser utilizado em Python para acessar os atributos es­pe­cí­fi­cos de um objeto, com o objetivo de atualizar os res­pec­ti­vos valores. Assim sendo, é possível atribuir novos valores a cada atributo de forma direta. O código abaixo comprova:

person1.name = "Sarah"
person1.age = 35

Neste próximo exemplo, a palavra-chave del é usada para excluir as pro­pri­e­da­des de um objeto:

del person1.name