Skip to main content

Class | Python

  • Class | Python
class Computer:
    computer_count = 0
    def __init__(self, cpus, architecture):
        self.cpus: int = cpus
        self.architecture: str = architecture
        Computer.computer_count += 1

    def power_on(self):
        print("Powering on computer")

    def shutdown(self):
        print("Shutting down computer")

    @classmethod
    def get_computer_count(cls):
        return cls.computer_count

    @staticmethod
    def is_small_computer(cpus):
        return cpus < 4

Métodos Dunder​

Criação e Representação de Objetos​

  1. __init__(self, ...) – Construtor, chamado quando um objeto é criado. Usado para inicializar atributos.
  2. __str__(self) – Representação amigável para usuários. Define o que é exibido ao usar print(obj).
  3. __repr__(self) – Representação voltada para desenvolvedores. Retorna uma string detalhada, útil para depuração (debug).

Manipulação de Estruturas de Dados​

  1. __len__(self) – Retorna o tamanho de um objeto, permitindo o uso de len(obj).
  2. __getitem__(self, key) – Permite acessar elementos por índice/chave (obj[key]).
  3. __setitem__(self, key, value) – Permite definir valores em índices (obj[key] = valor).
  4. __delitem__(self, key) – Permite deletar valores de um objeto usando índice (del obj[key]).

Comportamento de Função e Iteração​

  1. **call**(self, \*args, **kwargs) – Torna um objeto "chamável" como uma função (obj()).
  2. __iter__(self) – Torna o objeto iterável, permitindo uso em loops (for item in obj).
  3. __next__(self) – Retorna o próximo elemento em uma iteração.

Comparação e Operadores​

  1. __eq__(self, other) – Define comportamento do operador == (igualdade).
  2. __lt__(self, other) – Define comportamento do operador < (menor que, útil para ordenação).
  3. __add__(self, other) – Define comportamento do operador + (adição entre objetos personalizados, como vetores).

Classe abstrata | Python​

from abc import ABC, abstractmethod

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

    @abstractmethod
    def move(self):
        pass

class Dog(Animal):
    def make_sound(self):
        return "Woof!"

    def move(self):
        return "Runs"

class Bird(Animal):
    def make_sound(self):
        return "Chirp!"

    def move(self):
        return "Flies"

# Uso das classes
dog = Dog()
print(dog.make_sound())  # Saída: Woof!
print(dog.move())        # Saída: Runs

bird = Bird()
print(bird.make_sound()) # Saída: Chirp!
print(bird.move())       # Saída: Flies

Generics | Python​

from typing import TypeVar, Generic, List

T = TypeVar('T')

class Stack(Generic[T]):
    def __init__(self):
        self.items: List[T] = []

    def push(self, item: T):
        self.items.append(item)

    def pop(self) -> T:
        return self.items.pop()

    def peek(self) -> T:
        return self.items[-1]

    def is_empty(self) -> bool:
        return len(self.items) == 0

    def size(self) -> int:
        return len(self.items)

# Uso da classe Stack com diferentes tipos
int_stack = Stack[int]()
int_stack.push(1)
int_stack.push(2)
print(int_stack.pop())  # Saída: 2

str_stack = Stack[str]()
str_stack.push("a")
str_stack.push("b")
print(str_stack.pop())  # Saída: b