CLASS PYTHON

No Python, uma classe é um tipo de estrutura de dados que define um objeto específico e as ações que podem ser executadas nesse objeto. Em outras palavras, é uma forma de criar um novo tipo de dado personalizado que pode conter atributos e métodos.

As classes são importantes em Python porque elas permitem a criação de código modular e orientado a objetos. Ao criar uma classe, é possível encapsular dados e comportamentos relacionados em um único objeto, tornando o código mais organizado e fácil de entender. As classes também permitem que o código seja reutilizado em diferentes partes do programa, tornando-o mais eficiente e fácil de manter.

Além disso, as classes em Python permitem a criação de objetos que podem ter propriedades e métodos específicos. Por exemplo, uma classe “Carro” pode ter atributos como “cor“, “marca“, “modelo” e métodos como “acelerar“, “frear” e “ligar“. Cada objeto criado a partir dessa classe terá essas mesmas propriedades e métodos, tornando mais fácil trabalhar com carros em um programa.

Outra vantagem das classes em Python é que elas permitem a implementação de herança e polimorfismo. Herança permite criar novas classes a partir de classes existentes, mantendo os atributos e métodos da classe original. Polimorfismo permite que objetos de diferentes classes sejam tratados da mesma maneira em certos casos, tornando o código mais flexível e extensível.

Em resumo, as classes em Python são uma poderosa ferramenta de programação orientada a objetos que permitem criar tipos de dados personalizados, encapsular dados e comportamentos relacionados, reutilizar código e implementar herança e polimorfismo.

Como criar uma classe em Python e definir seus atributos e métodos

Para criar uma classe em Python, você pode usar a palavra-chave “class” seguida pelo nome da classe. A definição da classe é seguida por dois-pontos “:” e o bloco de código da classe é indentado. Aqui está um exemplo de como criar uma classe simples em Python:

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

    def apresentar(self):
        print(f"Olá, meu nome é {self.nome} e tenho {self.idade} anos.")

Nesse exemplo, criamos uma classe chamada “Pessoa” que tem dois atributos: “nome” e “idade“. Além disso, definimos um método “apresentar” que imprime uma mensagem com o nome e a idade da pessoa.

O método __init__ é um método especial em Python que é executado automaticamente sempre que um novo objeto é criado a partir da classe. Nesse caso, ele define os atributos de instância “nome” e “idade” para o objeto recém-criado.

Agora, para criar um objeto a partir da classe “Pessoa”, basta chamar o nome da classe seguido de parênteses e passar os argumentos necessários para o método __init__. Aqui está um exemplo:

pessoa1 = Pessoa("João", 25)
pessoa1.apresentar()

Nesse exemplo, criamos um objeto chamado “pessoa1” com nome “João” e idade 25. Em seguida, chamamos o método “apresentar” para imprimir a mensagem com os dados da pessoa.

Você também pode adicionar mais métodos à classe, como por exemplo:

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

    def apresentar(self):
        print(f"Olá, meu nome é {self.nome} e tenho {self.idade} anos.")

    def fazer_aniversario(self):
        self.idade += 1
        print(f"Parabéns! Agora tenho {self.idade} anos.")

Nesse exemplo, adicionamos um novo método chamado “fazer_aniversario” que incrementa a idade da pessoa em 1 e imprime uma mensagem de parabéns.

Agora, podemos criar um objeto e chamar o novo método:

pessoa1 = Pessoa("João", 25)
pessoa1.fazer_aniversario()  # Parabéns! Agora tenho 26 anos.

A diferença entre atributos de instância e atributos de classe em Python

Em Python, existem duas categorias de atributos em uma classe: os atributos de instância e os atributos de classe. A principal diferença entre eles é que os atributos de instância pertencem a cada objeto criado a partir da classe, enquanto os atributos de classe pertencem à classe em si.

Atributos de instância são definidos no método __init__ e são criados para cada objeto que é instanciado a partir da classe. Eles podem ser acessados através do objeto, usando a sintaxe objeto.atributo. Aqui está um exemplo:

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

pessoa1 = Pessoa("João", 25)
print(pessoa1.nome)  # João
print(pessoa1.idade)  # 25

Nesse exemplo, criamos uma classe “Pessoa” com dois atributos de instância: “nome” e “idade“. Quando criamos um novo objeto a partir da classe (“pessoa1“), esses atributos são definidos para esse objeto. Podemos acessar esses atributos usando a sintaxe objeto.atributo.

Por outro lado, atributos de classe são definidos fora do método __init__, diretamente na classe. Eles pertencem à classe em si e são compartilhados por todos os objetos criados a partir da classe. Eles podem ser acessados através da sintaxe Classe.atributo. Aqui está um exemplo:

class Pessoa:
    especie = "humano"

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

pessoa1 = Pessoa("João", 25)
print(pessoa1.especie)  # humano
print(Pessoa.especie)   # humano

Pessoa.especie = "homo sapiens"
print(pessoa1.especie)  # homo sapiens
print(Pessoa.especie)   # homo sapiens

Nesse exemplo, criamos um atributo de classe chamado “especie” com o valor “humano“. Esse atributo é compartilhado por todos os objetos criados a partir da classe. Podemos acessá-lo tanto através do objeto (pessoa1.especie) quanto da classe (Pessoa.especie). Também podemos modificar o valor do atributo de classe, e essa mudança será refletida em todos os objetos criados a partir da classe.

Em resumo, a diferença entre atributos de instância e atributos de classe em Python é que os primeiros pertencem a cada objeto criado a partir da classe, enquanto os segundos pertencem à classe em si e são compartilhados por todos os objetos.

Criando objetos a partir de uma classe

Em Python, objetos são criados a partir de classes usando a sintaxe nome_da_classe(argumentos) para chamar o construtor da classe. Depois de criar um objeto, você pode acessar seus atributos e métodos usando a sintaxe objeto.atributo e objeto.metodo(), respectivamente.

Aqui está um exemplo de como criar um objeto a partir de uma classe em Python e acessar seus atributos e métodos:

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

    def dizer_ola(self):
        print(f"Olá, meu nome é {self.nome} e eu tenho {self.idade} anos.")

# Criar um objeto Pessoa
pessoa1 = Pessoa("João", 25)

# Acessar os atributos do objeto
print(pessoa1.nome)  # João
print(pessoa1.idade)  # 25

# Chamar um método do objeto
pessoa1.dizer_ola()  # Olá, meu nome é João e eu tenho 25 anos.

Nesse exemplo, criamos uma classe “Pessoa” com um construtor que define dois atributos de instância: “nome” e “idade“. Também criamos um método chamado “dizer_ola” que imprime uma mensagem de saudação usando os atributos do objeto. Depois, criamos um objeto “pessoa1” a partir da classe “Pessoa“, passando os argumentos “João” e 25 para o construtor. Em seguida, acessamos os atributos do objeto usando a sintaxe pessoa1.nome e pessoa1.idade. Finalmente, chamamos o método do objeto usando a sintaxe pessoa1.dizer_ola(), que imprime a mensagem “Olá, meu nome é João e eu tenho 25 anos.“.

Observe que, ao chamar um método de um objeto, você precisa incluir os parênteses () após o nome do método, mesmo que o método não receba nenhum argumento (como é o caso do método “dizer_ola” neste exemplo). Se você não incluir os parênteses, você estará se referindo ao método em si, em vez de chamar o método e executar seu código.

Como herdar de uma classe em Python

Em Python, a herança é usada para criar uma nova classe que é uma versão modificada de uma classe existente (a classe base). A nova classe (a classe derivada) herda os atributos e métodos da classe base e pode adicionar ou substituir atributos e métodos. Para herdar de uma classe em Python, você deve definir a nova classe e especificar a classe base na definição da classe, usando a sintaxe class NovaClasse(ClasseBase):.

Aqui está um exemplo de como herdar de uma classe em Python:

# Definir a classe base
class Animal:
    def __init__(self, nome):
        self.nome = nome

    def fazer_som(self):
        print("O animal faz um som.")

# Definir a classe derivada
class Cachorro(Animal):
    def __init__(self, nome, raca):
        super().__init__(nome)
        self.raca = raca

    def fazer_som(self):
        print("O cachorro late.")

# Criar um objeto Cachorro
meu_cachorro = Cachorro("Rex", "Pastor Alemão")

# Acessar os atributos e métodos do objeto
print(meu_cachorro.nome)  # Rex
print(meu_cachorro.raca)  # Pastor Alemão
meu_cachorro.fazer_som()  # O cachorro late.

Nesse exemplo, definimos a classe base “Animal” com um construtor que define um atributo “nome” e um método “fazer_som“. Em seguida, definimos a classe derivada “Cachorro” que herda da classe base “Animal” e adiciona um novo atributo “raca” e um novo método “fazer_som” que substitui o método da classe base. Ao criar um objeto “Cachorro” chamado “meu_cachorro“, podemos acessar os atributos e métodos do objeto usando a sintaxe meu_cachorro.nome, meu_cachorro.raca e meu_cachorro.fazer_som().

Observe que usamos a função super().__init__(nome) no construtor da classe derivada para chamar o construtor da classe base e definir o atributo “nome“. Isso é necessário porque a classe derivada substitui o construtor da classe base e, sem a chamada super().__init__(nome), o atributo “nome” não seria definido.

Criar uma hierarquia de classes

Criar uma hierarquia de classes em Python envolve a definição de uma classe base e uma ou mais classes derivadas que herdam da classe base. A classe base contém atributos e métodos que são comuns a todas as classes derivadas, enquanto as classes derivadas adicionam atributos e métodos específicos a elas.

Por exemplo, imagine que estamos criando um programa para gerenciar uma biblioteca. Podemos definir uma classe base “ItemBiblioteca” com atributos como título, autor e data de publicação. Em seguida, podemos definir classes derivadas como “Livro” e “Revista“, que herdam de “ItemBiblioteca” e adicionam atributos e métodos específicos a eles. O “Livro” pode ter um atributo adicional como “número de páginas“, enquanto a “Revista” pode ter um atributo como “número de edição“.

Aqui está um exemplo de código:

class ItemBiblioteca:
    def __init__(self, titulo, autor, data_publicacao):
        self.titulo = titulo
        self.autor = autor
        self.data_publicacao = data_publicacao

    def detalhes(self):
        print(f"Título: {self.titulo}")
        print(f"Autor: {self.autor}")
        print(f"Data de Publicação: {self.data_publicacao}")


class Livro(ItemBiblioteca):
    def __init__(self, titulo, autor, data_publicacao, num_paginas):
        super().__init__(titulo, autor, data_publicacao)
        self.num_paginas = num_paginas

    def detalhes(self):
        super().detalhes()
        print(f"Número de páginas: {self.num_paginas}")


class Revista(ItemBiblioteca):
    def __init__(self, titulo, autor, data_publicacao, num_edicao):
        super().__init__(titulo, autor, data_publicacao)
        self.num_edicao = num_edicao

    def detalhes(self):
        super().detalhes()
        print(f"Número da Edição: {self.num_edicao}")


# Criar objetos das classes
meu_livro = Livro("Aprendendo Python", "João Silva", "2021-01-01", 300)
minha_revista = Revista("Revista Python", "Maria Souza", "2021-05-01", 10)

# Acessar os atributos e métodos dos objetos
meu_livro.detalhes()
# Título: Aprendendo Python
# Autor: João Silva
# Data de Publicação: 2021-01-01
# Número de páginas: 300

minha_revista.detalhes()
# Título: Revista Python
# Autor: Maria Souza
# Data de Publicação: 2021-05-01
# Número da Edição: 10

Nesse exemplo, definimos a classe base “ItemBiblioteca” com atributos comuns a todos os itens da biblioteca, como “titulo“, “autor” e “data_publicacao“, e um método “detalhes” para imprimir esses atributos. Em seguida, definimos duas classes derivadas, “Livro” e “Revista“, que herdam da classe base “ItemBiblioteca” e adicionam atributos específicos a eles, como “num_paginas” e “num_edicao“, respectivamente. Finalmente, criamos objetos dessas classes e acessamos seus atributos e métodos usando a sintaxe de objeto padrão do Python.

É importante notar que, ao definir uma hierarquia de classes em Python, as classes derivadas herdam todos os atributos e métodos da classe base. Isso significa que podemos chamar o método “detalhes” da classe base em uma classe derivada, como fizemos no exemplo acima com a chamada super().detalhes(). Além disso, as classes derivadas podem substituir os métodos da classe base com suas próprias implementações, como fizemos com o método “detalhes” nas classes “Livro” e “Revista“.

Métodos especiais em Python e como usá-los em uma classe

Existem alguns métodos especiais que podemos definir em uma classe, também conhecidos como métodos mágicos ou dunder methods (abreviação de double underscore methods). Esses métodos são invocados automaticamente em determinadas situações, como quando criamos um objeto da classe, quando usamos operadores como “+” ou “–” com objetos da classe, ou quando usamos funções embutidas como “len()” ou “str()” em objetos da classe. Aqui estão alguns exemplos de métodos especiais em Python e como usá-los em uma classe:

1 – __init__(): É o método construtor da classe, usado para inicializar os atributos do objeto quando ele é criado. É invocado automaticamente quando criamos um objeto da classe. Exemplo:

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

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

2 – __str__(): É o método que retorna a representação em string do objeto. É invocado automaticamente quando usamos a função “str()” em um objeto da classe. Exemplo:

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

    def __str__(self):
        return f"Nome: {self.nome}, Idade: {self.idade}"

p1 = Pessoa("João", 30)
print(str(p1))  # Nome: João, Idade: 30

3 – __add__(): É o método que define a operação de adição para objetos da classe. É invocado automaticamente quando usamos o operador “+” com objetos da classe. Exemplo:

class Ponto:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __add__(self, other):
        return Ponto(self.x + other.x, self.y + other.y)

p1 = Ponto(1, 2)
p2 = Ponto(3, 4)
p3 = p1 + p2
print(p3.x, p3.y)  # 4 6

4 – __len__(): É o método que retorna o comprimento do objeto. É invocado automaticamente quando usamos a função “len()” em um objeto da classe. Exemplo:

class ListaNumeros:
    def __init__(self, numeros):
        self.numeros = numeros

    def __len__(self):
        return len(self.numeros)

ln = ListaNumeros([1, 2, 3, 4, 5])
print(len(ln))  # 5

Esses são apenas alguns exemplos de métodos especiais em Python. Existem muitos outros, como __eq__(), __lt__(), __gt(), __getitem__(), __setitem__(), __delitem(), entre outros. Para usar esses métodos em uma classe, basta definir o método na classe com o nome correspondente e o Python cuidará de invocá-lo automaticamente nas situações apropriadas.

Encapsulamento em Python para controlar o acesso aos atributos de uma classe

O encapsulamento em Python é uma técnica que permite controlar o acesso aos atributos de uma classe, definindo o grau de visibilidade deles. Em outras palavras, encapsulamento é a prática de tornar certos membros de uma classe privados e outros públicos.

Em Python, a convenção é que os atributos de uma classe que começam com um underscore (_), devem ser tratados como privados e não devem ser acessados diretamente fora da classe. Além disso, a partir da versão 3.3, Python adicionou uma nova sintaxe para criar atributos privados, que é adicionando dois underscores (__). Essa técnica é chamada de “name mangling” e faz com que o Python renomeie o atributo adicionando o nome da classe como prefixo.

Para controlar o acesso aos atributos de uma classe, podemos definir métodos de acesso, também conhecidos como getters e setters, que permitem acessar e modificar os atributos privados da classe. Aqui está um exemplo de encapsulamento em Python:

class Pessoa:
    def __init__(self, nome, idade):
        self.nome = nome
        self.idade = idade
        self._cpf = None  # atributo privado com um underscore

    def get_cpf(self):
        return self._cpf

    def set_cpf(self, cpf):
        self._cpf = cpf

p1 = Pessoa("João", 30)
print(p1.nome)  # "João"
p1.set_cpf("123456789")
print(p1.get_cpf())  # "123456789"

Neste exemplo, criamos uma classe “Pessoa” com um atributo privado “_cpf” e definimos dois métodos, “get_cpf()” e “set_cpf()“, para acessar e modificar esse atributo. Note que não é possível acessar o atributo “_cpf” diretamente fora da classe, mas podemos usar os métodos de acesso para isso.

O encapsulamento em Python é uma boa prática de programação porque ajuda a controlar o acesso aos dados de uma classe e protege contra alterações inesperadas em seus atributos. Além disso, o encapsulamento facilita a manutenção do código, pois torna mais fácil mudar a implementação interna de uma classe sem afetar o código externo que a utiliza.

A diferença entre classes abstratas e concretas em Python

Classes abstratas e concretas são dois tipos de classes em Python que têm propósitos diferentes.

Uma classe concreta é uma classe que pode ser instanciada e usada diretamente. Ela contém a implementação completa de todos os seus métodos e pode ser usada para criar objetos. Em outras palavras, uma classe concreta é uma classe que pode ser usada diretamente para criar objetos e realizar operações.

Por outro lado, uma classe abstrata é uma classe que não pode ser instanciada diretamente. Ela é uma classe que fornece uma interface comum para todas as suas subclasses, mas não contém implementações completas de todos os seus métodos. Em outras palavras, uma classe abstrata é uma classe que serve apenas como um modelo para outras classes derivadas e não pode ser usada diretamente para criar objetos.

Em Python, podemos definir classes abstratas usando o módulo abc (Abstract Base Classes). Para criar uma classe abstrata, devemos definir pelo menos um método abstrato, que é um método que não contém uma implementação e deve ser definido nas subclasses. Veja um exemplo:

from abc import ABC, abstractmethod

class Animal(ABC):
    @abstractmethod
    def emitir_som(self):
        pass

class Cachorro(Animal):
    def emitir_som(self):
        print("Au au!")

class Gato(Animal):
    def emitir_som(self):
        print("Miau!")

a = Cachorro()
a.emitir_som()  # "Au au!"

b = Gato()
b.emitir_som()  # "Miau!"

Neste exemplo, criamos uma classe abstrata “Animal” com um método abstrato “emitir_som()“. Em seguida, criamos duas subclasses “Cachorro” e “Gato” que implementam o método “emitir_som()” de maneiras diferentes. Note que não é possível instanciar diretamente a classe abstrata “Animal“, mas podemos instanciar as subclasses “Cachorro” e “Gato” e usá-las para criar objetos.

Em resumo, a principal diferença entre classes abstratas e concretas em Python é que as classes abstratas não podem ser instanciadas diretamente e servem apenas como modelos para outras classes derivadas, enquanto as classes concretas podem ser instanciadas e usadas diretamente para criar objetos.

Considerações Finais

Neste artigo, discutimos vários tópicos relacionados a classes em Python, incluindo como criar classes, definir atributos e métodos, herdar de classes e criar hierarquias de classes, utilizar métodos especiais, encapsular atributos e usar propriedades para criar atributos com getters e setters personalizados. Além disso, também discutimos a diferença entre classes abstratas e concretas em Python.

Classes são uma parte fundamental da programação orientada a objetos em Python e nos permitem criar objetos complexos que podem ser usados para modelar problemas do mundo real. Ao usar classes, podemos agrupar dados e comportamentos relacionados em uma única entidade, facilitando a organização e a manutenção do código.

A herança de classes nos permite criar novas classes que herdam comportamentos e atributos de uma classe pai, o que nos permite reutilizar o código e evitar a duplicação desnecessária. Além disso, podemos criar hierarquias de classes que nos permitem modelar problemas complexos de maneira mais eficiente.

Os métodos especiais nos permitem personalizar o comportamento padrão das classes em Python, permitindo que nossas classes se comportem de maneira mais natural e intuitiva. Por outro lado, o encapsulamento nos permite controlar o acesso aos atributos de uma classe e garantir que o estado interno da classe não seja corrompido por operações externas.

Por fim, as propriedades em Python nos permitem criar atributos com getters e setters personalizados, permitindo que controlemos de forma mais precisa o acesso e a modificação dos atributos de uma classe.

Em resumo, as classes em Python são uma ferramenta poderosa que nos permite criar código organizado, modular e reutilizável. Ao entender os conceitos discutidos neste artigo, você estará preparado para criar suas próprias classes em Python e utilizá-las para resolver problemas complexos de programação.

Referências:

Veja também!

Powered by  GDPR Cookie Compliance
Políticas de privacidade

Este site usa cookies para que possamos fornecer a melhor experiência de usuário possível. As informações de cookies são armazenadas em seu navegador e executam funções como reconhecê-lo quando você retorna ao nosso site e ajudar nossa equipe a entender quais seções do site você considera mais interessantes e úteis.