Mis apuntes · Aprende Python desde PHP

Se guardan solos en este navegador mientras escribes. Puedes usar Markdown. Al descargarlos, la primera línea es tu enlace personal al curso.

Lección 21 de 47 · De clases a clases ✦ WebMCP implementado

class, __init__ y self: el $this explícito

10 min de lectura 4 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.

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:

Pythonmain.py
class Tarea:
    def __init__(self, id, titulo):
        self.id = id
        self.titulo = titulo
        self.hecha = False

    def completar(self):
        self.hecha = True


tarea = Tarea(1, "Comprar pan")
print(tarea.titulo, tarea.hecha)

tarea.completar()
print(tarea.titulo, tarea.hecha)

Ahora la misma clase en PHP 8.5, lado a lado:

PHP 8.5Tarea.php
<?php
declare(strict_types=1);

final class Tarea
{
    public bool $hecha = false;

    public function __construct(
        public int $id,
        public string $titulo,
    ) {
    }

    public function completar(): void
    {
        $this->hecha = true;
    }
}

$tarea = new Tarea(1, "Comprar pan");
echo $tarea->titulo . " " . var_export($tarea->hecha, true) . PHP_EOL;
$tarea->completar();
echo $tarea->titulo . " " . var_export($tarea->hecha, true) . PHP_EOL;
Pythonmain.py
class Tarea:
    def __init__(self, id, titulo):
        self.id = id
        self.titulo = titulo
        self.hecha = False

    def completar(self):
        self.hecha = True


tarea = Tarea(1, "Comprar pan")
print(tarea.titulo, tarea.hecha)
tarea.completar()
print(tarea.titulo, tarea.hecha)
  1. Sin new: Tarea(1, "Comprar pan") ya crea el objeto y llama a __init__.
  2. 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__.
  3. 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.
  4. 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
class Tarea:
    def __init__(self, titulo):
        self.titulo = titulo

    # Olvido a propósito el self: aquí falta el hueco para el objeto.
    def completar():
        print("completada")


tarea = Tarea("Comprar pan")
try:
    tarea.completar()
except TypeError as 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
class Tarea:
    # En PHP: public static int $creadas = 0;
    creadas = 0

    def __init__(self, titulo):
        self.titulo = titulo
        Tarea.creadas += 1


Tarea("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)
PHP 8.5Tarea.php
<?php
declare(strict_types=1);

final class Tarea
{
    public static int $creadas = 0;

    public function __construct(public string $titulo)
    {
        self::$creadas++;
    }
}

new Tarea("Comprar pan");
new Tarea("Llamar al banco");
echo Tarea::$creadas . PHP_EOL;
Pythonmain.py
class Tarea:
    creadas = 0

    def __init__(self, titulo):
        self.titulo = titulo
        Tarea.creadas += 1


Tarea("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
class Tarea:
    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 = 3
print(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?
titulopúblico (el valor por defecto)Sí
_titulointerno, por convenciónSí (pero la comunidad espera que no lo hagas)
__tituloname mangling: Python lo renombra a _Tarea__tituloCon ese nombre largo, sí. Con __titulo no
Pythonmain.py
class Tarea:
    def __init__(self, id, titulo):
        self.titulo = titulo
        self._notas = []
        self.__id = id

    def identificador(self):
        return self.__id


tarea = Tarea(7, "Comprar pan")
print(tarea.titulo)
print(tarea._notas)
print(tarea.identificador())

try:
    print(tarea.__id)
except AttributeError as error:
    print("AttributeError:", error)

print(tarea._Tarea__id)
print(sorted(vars(tarea)))

¿Por qué? · En PHP no existe

¿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.

Pythonmain.py
class Tarea:
    def __init__(self, id, titulo):
        self.id = id
        self.titulo = titulo
        self.hecha = False

    def __str__(self):
        marca = "x" if self.hecha else " "
        return f"[{marca}] {self.titulo}"

    def __repr__(self):
        return f"Tarea(id={self.id!r}, titulo={self.titulo!r})"

    def __eq__(self, otra):
        if not isinstance(otra, Tarea):
            return NotImplemented
        return self.id == otra.id


tarea = Tarea(1, "Comprar pan")
print(tarea)
print(repr(tarea))
print([tarea])
print(tarea == Tarea(1, "Otro título"), tarea == Tarea(2, "Comprar pan"), tarea == 1)
PHP 8.5Tarea.php
<?php
declare(strict_types=1);

final class Tarea
{
    public bool $hecha = false;

    public function __construct(public int $id, public string $titulo)
    {
    }

    public function __toString(): string
    {
        $marca = $this->hecha ? "x" : " ";
        return "[$marca] {$this->titulo}";
    }

    public function esIgual(self $otra): bool
    {
        return $this->id === $otra->id;
    }
}

$tarea = new Tarea(1, "Comprar pan");
echo $tarea . PHP_EOL;
var_dump($tarea->esIgual(new Tarea(1, "Otro título")));
Pythonmain.py
class Tarea:
    def __init__(self, id, titulo):
        self.id = id
        self.titulo = titulo
        self.hecha = False

    def __str__(self):
        marca = "x" if self.hecha else " "
        return f"[{marca}] {self.titulo}"

    def __eq__(self, otra):
        if not isinstance(otra, Tarea):
            return NotImplemented
        return self.id == otra.id


tarea = Tarea(1, "Comprar pan")
print(tarea)
print(tarea == Tarea(1, "Otro título"))
  • __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
class Tarea:
    def __init__(self, id, titulo):
        self.id = id
        self.titulo = titulo

    @classmethod
    def desde_texto(cls, texto):
        id_texto, titulo = texto.split(":", 1)
        return cls(int(id_texto), titulo.strip())

    @staticmethod
    def titulo_valido(titulo):
        return 0 < len(titulo.strip()) <= 50


class Urgente(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__)
PHP 8.5Tarea.php
<?php
declare(strict_types=1);

class Tarea
{
    public function __construct(public int $id, public string $titulo)
    {
    }

    public static function desdeTexto(string $texto): static
    {
        [$id, $titulo] = explode(":", $texto, 2);
        return new static((int) $id, trim($titulo));
    }

    public static function tituloValido(string $titulo): bool
    {
        return strlen(trim($titulo)) > 0 && strlen(trim($titulo)) <= 50;
    }
}

final class Urgente extends Tarea
{
}

$tarea = Tarea::desdeTexto("3: Comprar pan");
echo $tarea->id . " " . $tarea->titulo . PHP_EOL;
echo get_class(Urgente::desdeTexto("4:Llamar")) . PHP_EOL;
Pythonmain.py
class Tarea:
    def __init__(self, id, titulo):
        self.id = id
        self.titulo = titulo

    @classmethod
    def desde_texto(cls, texto):
        id_texto, titulo = texto.split(":", 1)
        return cls(int(id_texto), titulo.strip())


class Urgente(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.

PHPPythonQuién lo ve
__construct()__init__(self, ...)Se llama solo al hacer Tarea(...); sin new
$thisself (primer parámetro, explícito)Solo dentro del método
public int $id; declarado en la claseself.id = id dentro de __init__El atributo existe al asignarlo
public / protected / privatex / _x / __x (convención)Todos pueden acceder; el _ es un aviso
private de verdadNo existe__x solo cambia el nombre a _Clase__x
public static int $creadascreadas = 0 en el cuerpo de la claseTodos los objetos; se lee con Tarea.creadas
static function f() sin static::@staticmethodQuien llama a Tarea.f()
static function f() con new static@classmethod con clsQuien 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

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

Resumen

Lo que te llevas de esta lección

  1. __init__(self, ...) es el constructor y no hay new: Tarea(1, "Comprar pan") (en PHP, __construct() y new Tarea(...)).
  2. self se escribe: es el $this, primer parámetro de todo método, y los atributos nacen al asignarlos con self.x = ....
  3. 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).
  4. No hay private: _x es un cartel y __x solo renombra a _Clase__x para evitar choques en subclases.
  5. __str__ (__toString()), __repr__ y __eq__ los escribes tú; con __eq__ sin __hash__, el objeto deja de ser hashable.
  6. @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.