Como classes e objetos funcionam em Python?

Question

Accepted Answer

Uma **classe** é um blueprint para criar **objetos** (instâncias) que agrupam dados (atributos) e comportamento (métodos). A POO do Python é flexível e tem algumas convenções distintas, notavelmente o `self` explícito.

## Por que isso importa

Classes são como você modela entidades e organiza código em Python orientado a objetos — agrupando dados e comportamento relacionados, amplamente usadas em frameworks, modelagem de domínio e aplicações grandes.

Compreender as convenções distintivas do Python — o `self` explícito, construtor `__init__`, atributos de classe vs instância, os três tipos de método (`instance`/`@classmethod`/`@staticmethod`) e as convenções de privacidade com underscore — é essencial para escrever e ler Python orientado a objetos.

Elas diferem o suficiente de outras linguagens (self explícito, privacidade baseada em convenção) para que entendê-las bem previne confusão comum.

## Definindo uma classe

```python
class Dog:
    species = "Canis familiaris"     # CLASS attribute (shared by all instances)

def __init__(self, name, age):   # the constructor — runs on creation
        self.name = name              # INSTANCE attributes (per object)
        self.age = age

def bark(self):                   # a method — `self` is the instance
        return f"{self.name} says woof"

d = Dog("Rex", 3)        # create an instance (calls __init__)
d.name                   # "Rex"
d.bark()                 # "Rex says woof"
```

## O self explícito

```python
def bark(self):          # `self` is ALWAYS the first parameter of a method
    return self.name      # access instance data through self
```

Diferentemente de muitas linguagens com um `this` implícito, Python exige **`self`** como o primeiro parâmetro explícito de cada método de instância — refere-se à instância sobre a qual o método é chamado. Você não passa manualmente; `d.bark()` passa `d` como `self` automaticamente.

## Atributos de classe vs atributos de instância

```python
Dog.species          # "Canis familiaris" — shared by all dogs
d.species            # also accessible from an instance
d.name               # "Rex" — unique to this instance
```

Atributos de classe são compartilhados entre todas as instâncias; atributos de instância (definidos via `self.x =`) são por objeto.

## Tipos de método

```python
class Circle:
    def area(self): ...                    # instance method — needs self

@classmethod
    def from_diameter(cls, d):             # class method — receives the CLASS (cls)
        return cls(d / 2)                   # often used as alternative constructors

@staticmethod
    def pi(): return 3.14159               # static — no self/cls, just namespaced
```

## Convenções de encapsulamento

```python
self.public                # public
self._protected            # "internal use" by convention (not enforced)
self.__private             # name-mangled to _ClassName__private (stronger hiding)
```

Python não tem membros verdadeiramente privados — underscores iniciais são convenções sinalizando intenção ("não toque nisso"), não imposição rígida.