¿Cómo funcionan las clases y los objetos en Python?

Question

Accepted Answer

Una **clase** es un molde para crear **objetos** (instancias) que agrupan datos (atributos) y comportamiento (métodos). La POO de Python es flexible y tiene algunas convenciones distintivas, en particular el `self` explícito.

## Definir una clase

```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"
```

## El self explícito

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

A diferencia de muchos lenguajes con un `this` implícito, Python requiere **`self`** como el primer parámetro explícito de todo método de instancia — se refiere a la instancia sobre la que se llama el método. No lo pasas manualmente; `d.bark()` pasa `d` como `self` automáticamente.

## Atributos de clase vs de instancia

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

Los atributos de clase se comparten entre todas las instancias; los atributos de instancia (definidos con `self.x =`) son por objeto.

## Tipos de métodos

```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
```

## Convenciones de encapsulamiento

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

Python no tiene miembros verdaderamente privados — los guiones bajos iniciales son convenciones que señalan intención ("no toques esto"), no una aplicación estricta.

## Por qué es importante

Las clases son la forma de modelar entidades y organizar código en Python orientado a objetos — agrupando datos y comportamiento relacionados, usadas intensamente en frameworks, modelado de dominio y aplicaciones grandes.

Entender las convenciones distintivas de Python — el `self` explícito, el constructor `__init__`, los atributos de clase vs de instancia, los tres tipos de métodos (`instance`/`@classmethod`/`@staticmethod`) y las convenciones de privacidad con guion bajo — es esencial para escribir y leer Python orientado a objetos.

Estas difieren lo suficiente de otros lenguajes (self explícito, privacidad basada en convención) que conocerlas bien previene la confusión común.