Lección 21 de 47 · De clases a clases✦ WebMCP implementado
class, __init__ y self: el $this explícito
10 min de lectura4 retos
Una clase de Python se parece mucho a la de PHP, con tres diferencias que descolocan al principio: el constructor se llama __init__, el $this se escribe self y hay que ponerlo tú en cada método, y no existe private de verdad. En esta lección montas la clase Tarea de nuestra app y ves cada pieza frente a su equivalente de PHP.
¿De dónde vienen los nombres?
class = inglés class (clase, categoría)
Un molde para crear objetos. Igual que en PHP; solo cambia que no lleva llaves.
__init__ = inglés initialize (inicializar), con guiones bajos dobles
Se ejecuta justo después de crear el objeto y lo deja listo. Es tu __construct(). Los nombres con doble guion bajo a cada lado se llaman dunder (de double underscore).
self = inglés self (uno mismo)
El objeto sobre el que se llama al método. Es tu $this, pero aquí es un parámetro normal, escrito a la vista.
__str__ = inglés string (cadena de texto)
El texto «bonito» de un objeto, para print(). Es tu __toString().
__repr__ = inglés representation (representación)
El texto «técnico» de un objeto, pensado para el programador (idealmente, el código que lo recrea).
__eq__ = inglés equals (es igual a)
Lo que hace funcionar el operador == entre dos objetos de tu clase.
En 4 ideas
1/4
class Tarea: abre la clase sin llaves y __init__(self, ...) es el constructor. En PHP, __construct(); en Python, además, no hay new: se crea con Tarea(1, "Comprar pan"), llamando a la clase como si fuera una función.
self es el $thisescrito a mano: es el primer parámetro de todo método de instancia y se llama siempre con el punto (tarea.completar()), sin pasarlo tú. Y los atributos se crean al asignarlos (self.titulo = ...), no se declaran arriba.
No hay public/private/protected. Es una convención: _x significa «uso interno, no lo toques» y __x activa el name mangling (cambia el nombre para evitar choques en subclases). Nada de esto impide acceder desde fuera.
__str__ (__toString()), __repr__ y __eq__ se escriben a mano, y @classmethod / @staticmethod son los métodos static de PHP: el primero recibe la clase (cls, como static::), el segundo no recibe nada.
1 · Tu primera clase: class, __init__ y self
Piensa en una clase como el molde de las galletas y en cada objeto como una galleta. El molde (Tarea) dice qué forma tienen todas; cada galleta (cada tarea) tiene su propio sabor. Pulsa Ejecutar:
Sin new: Tarea(1, "Comprar pan") ya crea el objeto y llama a __init__.
Sin declarar los atributos arriba: self.hecha = False los crea en el momento de asignarlos. En PHP escribes public bool $hecha en la clase; en Python basta con asignar dentro de __init__.
Sin tipos obligatorios: puedes añadir titulo: str y -> None (lección de type hints), pero Python no los exige ni los comprueba al ejecutar.
El punto en vez de la flecha: tarea.titulo es el $tarea->titulo de PHP.
2 · self: el $this que tú escribes
En PHP, $this aparece dentro del método sin que lo declares. En Python, el objeto llega al método como primer parámetro y tú decides escribirlo. Por costumbre se llama siempre self.
Cuando escribes tarea.completar(), Python lo traduce a Tarea.completar(tarea): pasa el objeto como primer argumento. Por eso el def necesita un hueco para recibirlo. Mira qué pasa si te lo olvidas:
Pythonmain.py
classTarea:
def__init__(self, titulo):
self.titulo = titulo
# Olvido a propósito el self: aquí falta el hueco para el objeto.defcompletar():
print("completada")
tarea = Tarea("Comprar pan")
try:
tarea.completar()
exceptTypeErroras error:
print("TypeError:", error)
# Esto es lo que Python hace por dentro con tarea.titulo.upper():print(str.upper(tarea.titulo))
¿Por qué? · En PHP no existe
¿Por qué self es explícito? En PHP $this aparece solo
El lema de Python es «explícito es mejor que implícito». Con self a la vista no hay magia: un método es una función normal cuyo primer parámetro es el objeto. Por eso se puede guardar un método en una variable, pasarlo a map() o llamarlo como Tarea.completar(tarea) sin reglas especiales.
También evita una confusión típica de PHP: dentro de un método, titulo es una variable local y self.titulo es el atributo. En PHP, $titulo y $this->titulo también se distinguen, pero solo porque $this es una palabra reservada que aparece de la nada. Aquí lo ves en el propio def.
3 · Atributos de instancia y de clase
Los atributos que creas con self.x = ... dentro de un método pertenecen a cada objeto (de instancia): cada tarea tiene su titulo. Si escribes una variable directamente dentro de la clase, sin self, es un atributo de clase: existe una sola vez y la comparten todos los objetos. Es el static de PHP.
Pythonmain.py
classTarea:
# En PHP: public static int $creadas = 0;
creadas = 0def__init__(self, titulo):
self.titulo = titulo
Tarea.creadas += 1Tarea("Comprar pan")
Tarea("Llamar al banco")
print(Tarea.creadas)
# Leerlo desde un objeto también funciona: Python busca en el objeto y, si no está, en la clase.
tarea = Tarea("Repasar Python")
print(tarea.creadas, Tarea.creadas)
classTarea:
creadas = 0def__init__(self, titulo):
self.titulo = titulo
Tarea.creadas += 1Tarea("Comprar pan")
Tarea("Llamar al banco")
print(Tarea.creadas)
Hasta aquí es cómodo. La trampa llega cuando el atributo de clase es una lista (u otro objeto mutable): se comparte entre todos los objetos. Y si asignas desde un objeto, creas un atributo nuevo de instancia que tapa al de la clase, sin cambiarla:
Pythonmain.py
classTarea:
prioridad = 1
etiquetas = []
def__init__(self, titulo):
self.titulo = titulo
a = Tarea("Comprar pan")
b = Tarea("Llamar al banco")
# Asignar crea un atributo de instancia en a; la clase y b no cambian.
a.prioridad = 3print(a.prioridad, b.prioridad, Tarea.prioridad)
# Pero append MODIFICA la lista de la clase: la ven todos.
a.etiquetas.append("casa")
print(b.etiquetas, Tarea.etiquetas is a.etiquetas)
¿Por qué? · En PHP no existe
¿Por qué a.etiquetas.append(...) afecta a b? En PHP cada objeto tiene su array
En PHP, una propiedad de instancia como public array $etiquetas = []; se copia en cada objeto que creas, y los arrays además se copian al asignar. En Python, etiquetas = [] dentro de la clase se ejecuta una vez, al definir la clase, y crea una sola lista que a, b y la propia clase ven.
Es la misma raíz que la trampa del [] por defecto de la lección de mutable frente a inmutable: una expresión de la definición se evalúa una vez y el objeto resultante se comparte.
4 · Visibilidad: _x, __x y por qué no hay private
En PHP, private es una puerta con llave: si no eres la clase, no entras. En Python no hay puertas: hay carteles. El que escribe _x pone un cartel de «uso interno, por favor no lo toques»; el lenguaje no te lo impide.
Escribes…
Significa…
¿Se puede leer desde fuera?
titulo
público (el valor por defecto)
Sí
_titulo
interno, por convención
Sí (pero la comunidad espera que no lo hagas)
__titulo
name mangling: Python lo renombra a _Tarea__titulo
¿Por qué Python no tiene private de verdad? PHP sí
La filosofía de Python es «aquí todos somos adultos»: confía en que el programador no tocará lo interno sin motivo, y a cambio le deja hacerlo cuando de verdad lo necesita (depurar, escribir un test, arreglar un fallo de una biblioteca ajena sin esperar a su autor).
Entonces, ¿para qué sirve el doble guion bajo? No es para esconder: es para que una subclase pueda definir su propio __id sin pisar el de la clase padre. Python cambia el nombre a _Tarea__id y así no chocan. Para «esconder» de verdad, usa _x y confía en el cartel.
5 · __str__, __repr__ y __eq__
Si imprimes un objeto sin más, Python enseña algo poco útil, con la clase y una dirección de memoria. Para controlarlo hay dos métodos «especiales» (los llamados dunder): __str__ es el texto para el usuario y __repr__ el texto para el programador.
__str__ lo usan print(), str() y las f-strings (f"{tarea}"). Es tu __toString().
__repr__ lo usan repr(), el intérprete interactivo y las listas: print([tarea]) enseña el repr de cada elemento. Si solo escribes uno, que sea __repr__: print lo usa cuando no hay __str__.
__eq__ hace que == compare lo que tú quieras. Sin él, == entre objetos compara la identidad (si son el mismo objeto), como el === de PHP con objetos. Con él, == se parece a == de PHP, que compara las propiedades.
Devolver NotImplemented (no es una excepción) le dice a Python «no sé compararme con eso»; así tarea == 1 da False en vez de fallar.
6 · @classmethod y @staticmethod
Un método normal recibe self (el objeto). Python tiene otros dos tipos, que se marcan con un decorador (una etiqueta con @ encima del def; lo verás a fondo en el módulo 07):
@classmethod: recibe la clase como primer parámetro, por costumbre cls. Sirve de «constructor alternativo»: Tarea.desde_texto("3:Comprar pan"). Es el new static(...) de PHP dentro de un método static.
@staticmethod: no recibe nada (ni self ni cls). Es una función normal que vive dentro de la clase por orden. Es un método static de PHP que no usa static::.
Pythonmain.py
classTarea:
def__init__(self, id, titulo):
self.id = id
self.titulo = titulo
@classmethoddefdesde_texto(cls, texto):
id_texto, titulo = texto.split(":", 1)
returncls(int(id_texto), titulo.strip())
@staticmethoddeftitulo_valido(titulo):
return0 < len(titulo.strip()) <= 50classUrgente(Tarea):
pass
tarea = Tarea.desde_texto("3: Comprar pan")
print(tarea.id, tarea.titulo)
print(Tarea.titulo_valido(""), Tarea.titulo_valido("Comprar pan"))
# cls es la clase que lo llamó: en una subclase, crea un objeto de la subclase.print(type(Urgente.desde_texto("4:Llamar")).__name__)
classTarea:
def__init__(self, id, titulo):
self.id = id
self.titulo = titulo
@classmethoddefdesde_texto(cls, texto):
id_texto, titulo = texto.split(":", 1)
returncls(int(id_texto), titulo.strip())
classUrgente(Tarea):
pass
tarea = Tarea.desde_texto("3: Comprar pan")
print(tarea.id, tarea.titulo)
print(type(Urgente.desde_texto("4:Llamar")).__name__)
¿Por qué? · En PHP no existe
¿Por qué existen los dos? En PHP todo es static
En PHP, static sirve para ambas cosas, y para saber «qué clase soy» usas static::. Python separa los casos: si el método necesita la clase (para crear objetos de ella o de sus subclases), es @classmethod; si no necesita nada, es @staticmethod, y entonces suele ser mejor sacarlo como una función suelta del módulo.
Y como cls es un parámetro, no hace falta la palabra mágica static::: cls(...) crea siempre la clase correcta, también en las subclases.
7 · Equivalencia POO: PHP frente a Python
Equivalencia POO · PHP → Python
Todo lo que has visto, de un vistazo. La columna de la derecha dice quién puede ver o usar cada cosa.
PHP
Python
Quién lo ve
__construct()
__init__(self, ...)
Se llama solo al hacer Tarea(...); sin new
$this
self (primer parámetro, explícito)
Solo dentro del método
public int $id; declarado en la clase
self.id = id dentro de __init__
El atributo existe al asignarlo
public / protected / private
x / _x / __x (convención)
Todos pueden acceder; el _ es un aviso
private de verdad
No existe
__x solo cambia el nombre a _Clase__x
public static int $creadas
creadas = 0 en el cuerpo de la clase
Todos los objetos; se lee con Tarea.creadas
static function f() sin static::
@staticmethod
Quien llama a Tarea.f()
static function f() con new static
@classmethod con cls
Quien llama a Tarea.f() o a una subclase
__toString()
__str__() (usuario) y __repr__() (programador)
print, f-strings, listas, depurador
== entre objetos (propiedades)
__eq__()
El operador ==; sin él, compara la identidad
new Tarea(...)
Tarea(...)
Llamar a la clase crea el objeto
Hora de practicar
Retos · 0/4 resueltos
Reto 1 de 4 · ✓ Resuelto
La tarea que se pinta sola
Completa la clase Tarea para que print(tarea) muestre [ ] Comprar pan mientras no esté hecha y [x] Comprar pan cuando lo esté. Tienes que escribir __str__ y completar. Es el __toString() de PHP.
Al pulsar Comprobar, unos tests ocultos prueban tu código en tu navegador, con Python 3.14.
Pythonmain.py · editable
Pista.completar pone self.hecha = True. En __str__ elige la marca con "x" if self.hecha else " " y devuelve una f-string.
Reto 2 de 4 · ✓ Resuelto
Cuenta las tareas creadas
Añade a Tarea un atributo de clasecreadas que empiece en 0 y suba en 1 cada vez que se crea una tarea. Es el public static int $creadas de PHP con self::$creadas++. Recuerda que se lee como Tarea.creadas.
Al pulsar Comprobar, unos tests ocultos prueban tu código en tu navegador, con Python 3.14.
Pythonmain.py · editable
Pista. Escribe creadas = 0 en el cuerpo de la clase y, dentro de __init__, Tarea.creadas += 1 (no self.creadas, que crearía un atributo de instancia).
Reto 3 de 4 · ✓ Resuelto
Tareas iguales por id
Escribe __eq__ para que dos tareas sean iguales si tienen el mismo id (aunque el título cambie), y que comparar con algo que no sea una Tarea devuelva NotImplemented. Escribe también __repr__ para que repr(Tarea(1, "Comprar pan")) sea Tarea(id=1, titulo='Comprar pan').
Al pulsar Comprobar, unos tests ocultos prueban tu código en tu navegador, con Python 3.14.
Pythonmain.py · editable
Pista. En __eq__: si not isinstance(otra, Tarea) devuelve NotImplemented; si no, compara los id. En __repr__, !r dentro de la f-string pone las comillas del título.
Reto 4 de 4 · ✓ Resuelto
Un constructor alternativo
Añade a Tarea el @classmethoddesde_texto(cls, texto): recibe "3:Comprar pan" y devuelve una tarea con id 3 (un int) y título Comprar pan (sin espacios sobrantes). Debe usar cls, para que una subclase cree objetos de la subclase. Añade también el @staticmethodtitulo_valido(titulo): True si el título, sin espacios, tiene entre 1 y 50 caracteres. Son los static de PHP, uno con new static.
Al pulsar Comprobar, unos tests ocultos prueban tu código en tu navegador, con Python 3.14.
Pythonmain.py · editable
Pista.texto.split(":", 1) parte en dos trozos por el primer :. Devuelve cls(int(id_texto), titulo.strip()). Para el título válido: 0 < len(titulo.strip()) <= 50.
Resumen
Lo que te llevas de esta lección
__init__(self, ...) es el constructor y no hay new: Tarea(1, "Comprar pan") (en PHP, __construct() y new Tarea(...)).
self se escribe: es el $this, primer parámetro de todo método, y los atributos nacen al asignarlos con self.x = ....
Lo de la clase se comparte; lo de cada objeto va dentro de __init__. Un etiquetas = [] en la clase es una lista única para todos (en PHP, cada objeto tiene su array).
No hay private: _x es un cartel y __x solo renombra a _Clase__x para evitar choques en subclases.
__str__ (__toString()), __repr__ y __eq__ los escribes tú; con __eq__ sin __hash__, el objeto deja de ser hashable.
@classmethod recibe cls (el new static de PHP) y @staticmethod no recibe nada (un static normal).
Para recordarlo: «Yo, mi clase y mi cartel»
YYo self: el objeto que llama al método
MMi clase cls y los atributos de clase, compartidos por todos
CCartel _x: aviso, no cerradura
Antes de escribir un método, pregúntate: ¿necesito yo (self), mi clase (cls) o nada? Y antes de esconder algo, recuerda que en Python solo hay carteles.