Criando classes e objetos

3.1 Criando uma classe

Criar classes em Python é uma parte importante da programação orientada a objetos (POO). Classes permitem criar novos tipos de dados que podem ter seus próprios atributos e métodos. Vamos dar uma olhada nos conceitos básicos e exemplos de criação de classes em Python.

Conceitos básicos

• Classe: um modelo para criar objetos. A classe define atributos e métodos que os objetos dessa classe terão.
• Objeto: uma instância da classe. O objeto possui todos os atributos e métodos definidos na classe.
• Atributo: uma variável associada a uma classe ou objeto.
• Método: uma função associada a uma classe ou objeto.

Atributos são, basicamente, variáveis internas de um objeto ou classe. Métodos são funções definidas dentro de uma classe. Esses termos vêm da POO e são usados juntamente com funções e variáveis.

Para declarar (criar) uma nova classe, usa-se a palavra-chave class. A sintaxe geral dessa operação é:

class NomeDaClasse:
    variavel1 = valor1
    variavelN = valorN
          
    def funcao1(self):
        código da função
            
    def funcaoM(self):
        código da função

Basicamente, pode-se dizer que uma classe é um pequeno programa (variáveis + funções) colocado em uma área nomeada separada — NomeDaClasse.

Depois que você criou uma classe, pode criar objetos (instâncias) dessa classe. Esse código parece ainda mais simples:

variavelX = NomeDaClasse()

Importante! Nomes de variáveis e métodos em Python são geralmente escritos em letras minúsculas. Nomes de classes - com maiúsculas. Também, ao escrever os nomes das classes, não utilizamos underscores. Se o nome da classe deve ser composto por várias palavras, cada uma delas é escrita com maiúscula.

Se você quiser acessar uma variável de classe/objeto, geralmente esse código se parece com isso:

variavelX.variavel1 = 10
variavelX.funcaoM()       

Mas há alguns detalhes, que vamos explorar em breve...

3.2 Trabalhando com o objeto

Tanto a classe quanto a instância da classe (objeto da classe) são objetos, portanto, ambos podem ter suas próprias variáveis e métodos.

Existem dois tipos de variáveis:

• Atributo/Variável/Campo da classe (class property)
• Atributo/Variável/Campo do objeto (object property)

E três tipos de métodos:

• Método/Função da classe (class method)
• Método/Função do objeto (instance method)
• Método estático (static method)

Os métodos diferem na forma como são declarados e como são chamados.

Métodos do objeto

Ao declarar um método do objeto, é necessário passar o primeiro parâmetro obrigatório — self. Ao chamar o método, esse parâmetro recebe a referência para o objeto (instance).

class MyClass:

    def instance_method(self):
        print(type(self))  # <class 'MyClass'>
                   

my_object = MyClass()
my_object.instance_method()
        

No exemplo acima, quando a função instance_method() começou a ser executada, uma referência para o objeto my_object foi passada para o parâmetro self.

Métodos de classe

Ao declarar um método de classe, é necessário passar o primeiro parâmetro obrigatório — cls. Ao chamar o método, esse parâmetro recebe a referência para a classe (class object). Além disso, o método de classe precisa ser marcado com o decorator classmethod, como no exemplo abaixo:

class MyClass:
    def instance_method(self):
        print(type(self))  # <class 'MyClass'>
        
    @classmethod
    def class_method(cls):
        print(type(cls))  # <class 'type'>
                   

my_object = MyClass()
my_object.instance_method()
MyClass.class_method()
        

No exemplo acima, quando a função class_method() começou a ser executada, uma referência para a classe MyClass foi passada para o parâmetro cls.

Método estático

Ao declarar um método estático, não é necessário passar nada, mas ele não será capaz de acessar os dados internos da classe. Além disso, o método precisa ser marcado com o decorator staticmethod, como no exemplo abaixo:

class MyClass:
    def instance_method(self):
        print(type(self))  # <class 'MyClass'>
        
    @classmethod
    def class_method(cls):
        print(type(cls))  # <class 'type'>
        
    @staticmethod
    def static_method():
        return "Este método não depende da instância ou da classe"
                   
my_object = MyClass()
my_object.instance_method()
MyClass.class_method()
MyClass.static_method() 
        

Um método estático é chamado de maneira muito semelhante a um método de classe, mas nem a referência para o objeto nem para a classe é passada para ele.

3.3 Variáveis de classe

Variáveis de classe

Para declarar uma variável (atributo) de classe, basta declará-la em qualquer lugar dentro da classe. Normalmente, isso é feito no início, antes de declarar os métodos da classe. Exemplo:

class MyClass:
    attribute = "Sou um atributo de classe"
        
    @classmethod
    def class_method(cls):
        print(cls.attribute)  # Sou um atributo de classe
                  
my_object = MyClass()
MyClass.class_method()

Se você deseja ler ou escrever um valor em uma variável de classe, utilize o objeto cls.

Em princípio, a variável de classe pode ser acessada até mesmo pelo próprio nome da classe:

class MyClass:
    attribute = "Sou um atributo de classe"
        
    @classmethod
    def class_method(cls):
        print(MyClass.attribute)  # Sou um atributo de classe
                  
my_object = MyClass()

print(MyClass.attribute)  # Sou um atributo de classe

Variáveis/campos do objeto

Variáveis do objeto (instance) — são os campos do objeto self. Você simplesmente trabalha com elas através de self.name. É para isso que o objeto self é passado para cada método do objeto.

Exemplo:

class MyClass:
    attribute = "Sou um atributo de classe"
        
    def set_name(self, name):
        self.name = name
        
    def print_name(self):
        print(self.name)    
                 
my_object = MyClass()
my_object.set_name("Campo do objeto chamado name") 
my_object.print_name()  # "Campo do objeto chamado name"
        

Toda vez que você chama um método do objeto, como o primeiro parâmetro (self), uma referência para o objeto, no qual você está chamando o método, é passada. Diferentes métodos do objeto podem acessar dados comuns através do uso do objeto self.