{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Objetos, lo justo\n",
    "\n",
    "Por qué df.head() lleva un punto, qué es un método, y cuándo te conviene crear una clase (spoiler: pocas veces).\n",
    "\n",
    "Cuaderno de soluciones del capítulo 9 de **Python desde cero**, de Miss Yera.\n",
    "\n",
    "Corre de arriba abajo. Si lo abres en Google Colab no necesitas instalar nada.\n",
    "\n",
    "Capítulo completo: https://missyera.com/guias/python-desde-cero/objetos/\n",
    "\n",
    "Este es el cuaderno de **soluciones**. Trae el código de cada ejercicio, la\n",
    "explicación de la trampa y la respuesta del quiz. Si vienes del cuaderno de\n",
    "práctica sin haberlo intentado, vuelve 🙂"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Hola! Este capítulo es corto a propósito"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Te lo digo de una: **para analizar datos necesitas entender objetos, no\n",
    "diseñarlos** 🌸\n",
    "\n",
    "He visto cursos que meten tres semanas de herencia y polimorfismo antes de\n",
    "tocar un CSV, y la gente sale creyendo que Python es dificilísimo. No lo es.\n",
    "\n",
    "Lo que sí necesitas es entender por qué escribes `df.head()` con\n",
    "punto y con paréntesis, y por qué `df.shape` lleva punto pero no\n",
    "paréntesis. Vamos a eso.\n",
    "\n",
    "Así que la pregunta de este capítulo es chiquita: **¿por qué unas cosas llevan paréntesis y otras no?** Contéstala y ya sabes lo único que hace falta saber de objetos para trabajar con datos 🌸"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Todo lo que has usado ya era un objeto"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "texto = 'Minimarket El Sol'\n",
    "\n",
    "print(type(texto))\n",
    "print(texto.upper())\n",
    "print(texto.count('l'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ese `texto` no es solo una cadena de letras: es un objeto de tipo\n",
    "`str` que viene con funciones pegadas. Esas funciones pegadas se\n",
    "llaman **métodos**, y se llaman con el punto.\n",
    "\n",
    "La lista también:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ventas = [480.37, 154.83]\n",
    "\n",
    "ventas.append(2480.84)\n",
    "print(ventas)\n",
    "print(ventas.count(154.83))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Atributo o método, que es la duda de todos\n",
    "\n",
    "Esta es la pregunta que quería resolverte con este capítulo:\n",
    "\n",
    "- 📊 **Atributo**: un dato que el objeto guarda. Se lee\n",
    "**sin paréntesis**.\n",
    "\n",
    "- ⚙️ **Método**: una acción que el objeto sabe hacer. Se llama\n",
    "**con paréntesis**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from datetime import date\n",
    "\n",
    "hoy = date(2026, 8, 15)\n",
    "\n",
    "print(hoy.year)          # atributo: un dato guardado\n",
    "print(hoy.month)\n",
    "print(hoy.weekday())     # metodo: calcula algo y lo devuelve\n",
    "print(hoy.isoformat())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Y esto es lo que pasa si te equivocas, que te va a pasar:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Esto revienta a propósito.** Se ejecuta dentro de un `try` para que puedas seguir con \"ejecutar todo\" y aun así ver la queja."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    print(hoy.year())\n",
    "except Exception as e:\n",
    "    print(f'{type(e).__name__}: {e}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Y la queja que tiene que salir es esta:\n",
    "\n",
    "```\n",
    "TypeError: 'int' object is not callable\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Léelo: `hoy.year` es un `int`, o sea el número 2026, y\n",
    "le pusiste paréntesis como si fuera una función. \"No es llamable\" significa\n",
    "justo eso 🙃\n",
    "\n",
    "Al revés también avisa:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(hoy.weekday)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "No revienta, pero mira lo que imprimió: te describió el método en vez de\n",
    "ejecutarlo. **Si tu salida dice \"method\" en alguna parte, te faltaron los\n",
    "paréntesis.** Guárdate ese truco, que en pandas lo vas a usar 💜\n",
    "\n",
    "Cuando dudes, `dir()` te lista todo lo que tiene un objeto:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print([n for n in dir(hoy) if not n.startswith('_')])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ese filtro del guion bajo saca los internos, que no te interesan por ahora."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Crear tu propia clase"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Una clase es el molde y un objeto es lo que sale del molde. Vamos con un\n",
    "ejemplo que sí tiene sentido."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Venta:\n",
    "    def __init__(self, cliente, ciudad, monto, unidades):\n",
    "        self.cliente = cliente\n",
    "        self.ciudad = ciudad\n",
    "        self.monto = monto\n",
    "        self.unidades = unidades\n",
    "\n",
    "    def precio_unitario(self):\n",
    "        return round(self.monto / self.unidades, 2)\n",
    "\n",
    "    def con_igv(self, igv=0.18):\n",
    "        return round(self.monto * (1 + igv), 2)\n",
    "\n",
    "v = Venta('C0045', 'Trujillo', 480.37, 10)\n",
    "\n",
    "print(v.cliente)\n",
    "print(v.precio_unitario())\n",
    "print(v.con_igv())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tres cosas y ya sabes leer cualquier clase:\n",
    "\n",
    "- 🏗️ `__init__` es lo que corre al crear el objeto. Ahí se guardan\n",
    "los datos.\n",
    "\n",
    "- 👉 `self` es \"este objeto en particular\". Va como primer argumento\n",
    "de todos los métodos y **nunca se pasa al llamarlos**: Python lo\n",
    "pone solo.\n",
    "\n",
    "- 💾 `self.cliente = cliente` guarda el dato dentro del objeto para\n",
    "que siga ahí después.\n",
    "\n",
    "Si te olvidas del `self`, pasa esto:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Esto revienta a propósito.** Se ejecuta dentro de un `try` para que puedas seguir con \"ejecutar todo\" y aun así ver la queja."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    class Mal:\n",
    "        def __init__(self, monto):\n",
    "            self.monto = monto\n",
    "\n",
    "        def doble():\n",
    "            return 0\n",
    "\n",
    "    Mal(100).doble()\n",
    "except Exception as e:\n",
    "    print(f'{type(e).__name__}: {e}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Y la queja que tiene que salir es esta:\n",
    "\n",
    "```\n",
    "TypeError: Mal.doble() takes 0 positional arguments but 1 was given\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python le pasó el objeto como primer argumento y el método no lo esperaba. Ese\n",
    "\"1 was given\" cuando tú no diste ninguno es la firma del `self`\n",
    "olvidado 😄\n",
    "\n",
    "### Que se imprima bonito"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Feo, ¿no? Se arregla con `__repr__`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Venta:\n",
    "    def __init__(self, cliente, ciudad, monto):\n",
    "        self.cliente = cliente\n",
    "        self.ciudad = ciudad\n",
    "        self.monto = monto\n",
    "\n",
    "    def __repr__(self):\n",
    "        return f'Venta({self.cliente}, {self.ciudad}, S/{self.monto})'\n",
    "\n",
    "print(Venta('C0045', 'Trujillo', 480.37))\n",
    "print([Venta('C0325', 'Lima', 524.9), Venta('C0260', 'Cusco', 154.83)])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Fíjate en la segunda línea: al imprimir una lista de objetos, cada uno usa su\n",
    "`__repr__`. Eso hace que depurar sea infinitamente más cómodo 🌟"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## dataclass: lo mismo con mucho menos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si la clase es solo para guardar datos, hay un atajo que te ahorra escribir el\n",
    "`__init__` y el `__repr__`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from dataclasses import dataclass\n",
    "\n",
    "@dataclass\n",
    "class Venta:\n",
    "    cliente: str\n",
    "    ciudad: str\n",
    "    monto: float\n",
    "    unidades: int = 1\n",
    "\n",
    "    def precio_unitario(self):\n",
    "        return round(self.monto / self.unidades, 2)\n",
    "\n",
    "v = Venta('C0045', 'Trujillo', 480.37, 10)\n",
    "print(v)\n",
    "print(v.precio_unitario())\n",
    "print(Venta('C0325', 'Lima', 524.9))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ese `@dataclass` de arriba es un decorador, o sea algo que le\n",
    "agrega comportamiento a la clase. Escribió el `__init__`, el\n",
    "`__repr__` y la comparación por ti.\n",
    "\n",
    "Y esos `: str` y `: float` son anotaciones de tipo. No\n",
    "obligan nada en tiempo de ejecución, pero tu editor las lee y te avisa si metes\n",
    "un texto donde iba un número 💜"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Y ahora la pregunta importante: ¿te hace falta una clase?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Casi siempre no. De verdad."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "| Situación | Qué usar |\n",
    "|---|---|\n",
    "| Una fila de datos suelta | Un diccionario |\n",
    "| Muchas filas con las mismas columnas | Un DataFrame de pandas |\n",
    "| Una transformación | Una función |\n",
    "| Datos y comportamiento que van SIEMPRE juntos | Ahí sí, una clase |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mira estas dos formas de hacer lo mismo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "venta_dict = {'cliente': 'C0045', 'monto': 480.37, 'unidades': 10}\n",
    "print(round(venta_dict['monto'] / venta_dict['unidades'], 2))\n",
    "\n",
    "venta_obj = Venta('C0045', 'Trujillo', 480.37, 10)\n",
    "print(venta_obj.precio_unitario())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para una fila, el diccionario gana por simple. Para tres mil filas,\n",
    "**ninguna de las dos**: ahí va pandas, que es el capítulo 12.\n",
    "\n",
    "Mi regla después de varios proyectos: **escribe funciones hasta que te\n",
    "duela, y recién ahí piensa en una clase**. La clase se justifica cuando\n",
    "llevas cinco funciones que reciben siempre los mismos tres argumentos. Ahí esos\n",
    "tres argumentos querían ser un objeto 🌸"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Que dos objetos iguales se reconozcan"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Esta es la que más rabia da la primera vez 😤"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Simple:\n",
    "    def __init__(self, nombre):\n",
    "        self.nombre = nombre\n",
    "\n",
    "a = Simple('Rosita')\n",
    "b = Simple('Rosita')\n",
    "print('con clase normal, a == b ->', a == b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dos objetos con exactamente el mismo contenido y Python dice que no son\n",
    "iguales. No está roto: por defecto, comparar dos objetos pregunta **si son\n",
    "el mismo objeto**, no si tienen lo mismo dentro.\n",
    "\n",
    "Y eso rompe cosas que ni te imaginas: buscar en una lista, quitar duplicados\n",
    "con un conjunto, comparar el antes y el después de un cálculo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from dataclasses import dataclass\n",
    "\n",
    "@dataclass\n",
    "class ConDataclass:\n",
    "    nombre: str\n",
    "\n",
    "c = ConDataclass('Rosita')\n",
    "d = ConDataclass('Rosita')\n",
    "print('con dataclass,    c == d ->', c == d)\n",
    "print('y buscando en una lista  ->', ConDataclass('Rosita') in [c])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El `@dataclass` escribe ese `==` por ti, y es la\n",
    "segunda razón para usarlo aunque la primera ya fuera suficiente 🎁"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## El error que hasta las dataclass te marcan"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si le pones una lista vacía como valor por defecto a un atributo, Python te\n",
    "para en seco."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Esto revienta a propósito.** Se ejecuta dentro de un `try` para que puedas seguir con \"ejecutar todo\" y aun así ver la queja."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    @dataclass\n",
    "    class Malo:\n",
    "        compras: list = []\n",
    "except Exception as e:\n",
    "    print(f'{type(e).__name__}: {e}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Y la queja que tiene que salir es esta:\n",
    "\n",
    "```\n",
    "ValueError: mutable default <class 'list'> for field compras is not allowed: use default_factory\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ese error es un regalo, y es el mismo problema del capítulo\n",
    "6: el valor por defecto se crea **una sola vez**, al\n",
    "definir la clase. Sin ese aviso, todos los clientes que crearas compartirían la\n",
    "misma lista de compras.\n",
    "\n",
    "La forma correcta lo dice el propio mensaje:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from dataclasses import field\n",
    "\n",
    "@dataclass\n",
    "class Bueno:\n",
    "    compras: list = field(default_factory=list)\n",
    "\n",
    "x = Bueno()\n",
    "y = Bueno()\n",
    "x.compras.append('venta 1')\n",
    "print('y.compras ->', y.compras)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`default_factory=list` significa \"llama a `list()` cada\n",
    "vez que crees uno\". Por eso `y` nace con su lista vacía y no con la\n",
    "de `x` 🧺\n",
    "\n",
    "Fíjate en la diferencia con el capítulo 6: allí el mismo\n",
    "error se cuela en silencio y aquí Python lo caza. Cuando una librería te obliga\n",
    "a hacerlo bien, agradécelo."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Y sin dataclass, sin aviso ninguno"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Arriba te dije que sin ese error todos los clientes compartirían la misma\n",
    "lista. Ahora te lo enseño pasando de verdad, porque en una clase normal\n",
    "**nadie te avisa** 😖"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ClienteMal:\n",
    "    compras = []\n",
    "\n",
    "    def __init__(self, codigo):\n",
    "        self.codigo = codigo\n",
    "\n",
    "    def compra(self, monto):\n",
    "        self.compras.append(monto)\n",
    "\n",
    "\n",
    "a = ClienteMal('C0045')\n",
    "b = ClienteMal('C0325')\n",
    "a.compra(480.37)\n",
    "b.compra(154.83)\n",
    "\n",
    "print('compras de a:', a.compras)\n",
    "print('compras de b:', b.compras)\n",
    "print('es la misma lista:', a.compras is b.compras)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dos clientes distintos, cada uno con una compra, y los dos ven las dos 🫠\n",
    "\n",
    "Lo que pasó es que `compras = []` está escrito\n",
    "**en la clase**, no dentro de `__init__`. Se creó una sola\n",
    "vez, cuando Python leyó el archivo, y todos los objetos que nazcan de esa clase\n",
    "apuntan a esa misma lista.\n",
    "\n",
    "La diferencia es exactamente esta:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "| Dónde lo escribes | Qué es | Quién lo tiene |\n",
    "|---|---|---|\n",
    "| Fuera de `__init__` | Atributo de clase | Uno solo, compartido por todos |\n",
    "| Dentro, con `self.` | Atributo de instancia | Uno por objeto |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se arregla moviendo la línea adentro: `self.compras = []` dentro de\n",
    "`__init__`. Ahí se crea una lista nueva en cada objeto, que es lo que\n",
    "querías 🩹\n",
    "\n",
    "Y por eso el `@dataclass` te para en seco en vez de dejarte hacer\n",
    "esto: te está ahorrando una tarde entera de mirar por qué a un cliente le aparecen\n",
    "las compras de otro.\n",
    "\n",
    "Ojo, que un atributo de clase no es malo: es perfecto para cosas que de verdad\n",
    "son iguales para todos, tipo `IGV = 0.18` o una lista de nombres de\n",
    "columnas que nadie va a modificar. Lo peligroso es cuando es\n",
    "**mutable** y alguien lo toca."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Otra forma de crear el objeto"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Casi siempre los datos no te llegan como argumentos bonitos: te llegan como\n",
    "una fila de un CSV. Y para eso está `@classmethod` 🏗️"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from dataclasses import dataclass, field\n",
    "\n",
    "\n",
    "@dataclass\n",
    "class ClienteBien:\n",
    "    codigo: str\n",
    "    compras: list = field(default_factory=list)\n",
    "\n",
    "    @classmethod\n",
    "    def desde_fila(cls, fila):\n",
    "        codigo, monto = fila.split(';')\n",
    "        return cls(codigo.strip(), [float(monto)])\n",
    "\n",
    "    @property\n",
    "    def total(self):\n",
    "        return round(sum(self.compras), 2)\n",
    "\n",
    "\n",
    "c = ClienteBien.desde_fila('C0045; 480.37')\n",
    "d = ClienteBien('C0325')\n",
    "c.compras.append(120.0)\n",
    "\n",
    "print(c)\n",
    "print(d)\n",
    "print('total de c      :', c.total)\n",
    "print('comparten lista :', c.compras is d.compras)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tres cosas ahí que vale la pena separar 🧩\n",
    "\n",
    "**El `@classmethod`** es un constructor alternativo.\n",
    "Recibe `cls`, que es la clase misma, en vez de `self`, y\n",
    "devuelve un objeto nuevo. Lo que consigues es que la lógica de \"cómo se lee una\n",
    "fila\" viva junto a la clase y no repartida por diez sitios.\n",
    "\n",
    "**El `@property`** es un método que se usa como si\n",
    "fuera un atributo: fíjate en que escribí `c.total` sin paréntesis. Para\n",
    "lo que se calcula a partir de lo que ya tienes, queda mucho más natural.\n",
    "\n",
    "**Y el `False` del final** confirma que\n",
    "`default_factory` funcionó: cada cliente tiene su propia lista, al\n",
    "revés que en la clase de arriba 💜\n",
    "\n",
    "Un patrón que uso mucho con esto: `desde_fila` para leer,\n",
    "`@property` para lo calculado, y una función suelta que recorre el CSV\n",
    "y devuelve la lista de objetos. Con eso, el resto del programa deja de saber cómo\n",
    "era el archivo 🗂️"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Herencia, que aquí se usa menos de lo que parece"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Heredar es decir \"esto es como aquello, pero con algo distinto\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "@dataclass\n",
    "class Cliente:\n",
    "    nombre: str\n",
    "    segmento: str\n",
    "\n",
    "    def descuento(self):\n",
    "        return 0.0\n",
    "\n",
    "    def ficha(self):\n",
    "        return f'{self.nombre} ({self.segmento}) descuento {self.descuento():.0%}'\n",
    "\n",
    "@dataclass\n",
    "class Mayorista(Cliente):\n",
    "    segmento: str = 'Mayorista'\n",
    "\n",
    "    def descuento(self):\n",
    "        return 0.15\n",
    "\n",
    "for c in [Cliente('Bodega Rosita', 'Bodega'), Mayorista('Distribuidora Lima')]:\n",
    "    print(c.ficha())\n",
    "\n",
    "print('Mayorista es un Cliente?', isinstance(Mayorista('X'), Cliente))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mira lo que pasó: `ficha` se escribió una sola vez, en\n",
    "`Cliente`, y cuando la llama un `Mayorista` usa\n",
    "**su** descuento. Eso se llama polimorfismo y suena mucho peor de\n",
    "lo que es 🎭\n",
    "\n",
    "Ahora la parte honesta, que casi ningún tutorial dice: **en análisis de\n",
    "datos vas a heredar poquísimo**. La herencia sirve cuando tienes varias\n",
    "cosas que se parecen mucho y se comportan distinto en un detalle. Un análisis\n",
    "normal tiene funciones y DataFrames, no jerarquías de clases.\n",
    "\n",
    "Dónde sí la vas a ver: heredando de algo que ya existe, como cuando escribes\n",
    "un transformador propio para scikit-learn. Ahí heredas porque la librería te lo\n",
    "pide, no porque tú lo diseñaras así 🔧"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ejercicios"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. Atributo o método\n",
    "\n",
    "De un texto, saca su largo, su versión en mayúsculas y\n",
    "cuántas veces aparece una letra. Di cuál de las tres es un atributo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t = 'Minimarket El Sol'\n",
    "\n",
    "print(len(t))\n",
    "print(t.upper())\n",
    "print(t.count('l'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "17\n",
    "MINIMARKET EL SOL\n",
    "2\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ninguna de las tres es un atributo: `len()` es una función suelta y\n",
    "las otras dos son métodos. Los textos casi no tienen atributos públicos, y por\n",
    "eso todo lleva paréntesis."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. Provoca el error de los paréntesis\n",
    "\n",
    "Con una fecha, llama a un atributo como si fuera método."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from datetime import date\n",
    "\n",
    "d = date(2026, 8, 15)\n",
    "print(d.day)\n",
    "print(d.day())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "TypeError: 'int' object is not callable\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. El método sin llamar\n",
    "\n",
    "Imprime un método sin los paréntesis y aprende a reconocer\n",
    "la salida."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t = 'hola'\n",
    "print(t.upper)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "<built-in method upper of str object at ...\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si en tu salida aparece la palabra \"method\", te faltaron los paréntesis. Es de\n",
    "los errores más rápidos de detectar una vez que sabes mirarlo."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4. Tu primera clase\n",
    "\n",
    "Crea una clase `Cliente` con nombre y ciudad, y\n",
    "un método que devuelva una etiqueta tipo \"Nombre (Ciudad)\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Cliente:\n",
    "    def __init__(self, nombre, ciudad):\n",
    "        self.nombre = nombre\n",
    "        self.ciudad = ciudad\n",
    "\n",
    "    def etiqueta(self):\n",
    "        return f'{self.nombre} ({self.ciudad})'\n",
    "\n",
    "print(Cliente('Bodega Rosa', 'Piura').etiqueta())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "Bodega Rosa (Piura)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5. Que se imprima bien\n",
    "\n",
    "Agrégale `__repr__` a esa clase e imprime una\n",
    "lista de dos clientes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Cliente:\n",
    "    def __init__(self, nombre, ciudad):\n",
    "        self.nombre = nombre\n",
    "        self.ciudad = ciudad\n",
    "\n",
    "    def __repr__(self):\n",
    "        return f'Cliente({self.nombre!r}, {self.ciudad!r})'\n",
    "\n",
    "print([Cliente('Bodega Rosa', 'Piura'), Cliente('Sol', 'Lima')])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "[Cliente('Bodega Rosa', 'Piura'), Cliente('Sol', 'Lima')]\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ese `!r` dentro del f-string aplica `repr()` al valor, y\n",
    "por eso salen las comillas. Es el detalle que hace que el repr se pueda copiar y\n",
    "pegar para recrear el objeto."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6. Con dataclass\n",
    "\n",
    "Reescribe la clase anterior como `dataclass` y\n",
    "compara cuánto código te ahorraste."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from dataclasses import dataclass\n",
    "\n",
    "@dataclass\n",
    "class Cliente:\n",
    "    nombre: str\n",
    "    ciudad: str\n",
    "    activo: bool = True\n",
    "\n",
    "print(Cliente('Bodega Rosa', 'Piura'))\n",
    "print(Cliente('Sol', 'Lima', activo=False))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "Cliente(nombre='Bodega Rosa', ciudad='Piura', activo=True)\n",
    "Cliente(nombre='Sol', ciudad='Lima', activo=False)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7. El self olvidado\n",
    "\n",
    "Escribe un método sin `self` a propósito y lee el\n",
    "mensaje de error con calma."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Pedido:\n",
    "    def total():\n",
    "        return 0\n",
    "\n",
    "Pedido().total()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "TypeError: Pedido.total() takes 0 positional arguments but 1 was given\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ese \"1 was given\" cuando tú no diste ninguno es el objeto que Python metió\n",
    "solo. Cuando veas ese mensaje, mira el `self`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 8. Diccionario o clase\n",
    "\n",
    "Guarda tres ventas de las dos formas y calcula el total.\n",
    "Después decide cuál te gusta más para este caso."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from dataclasses import dataclass\n",
    "\n",
    "@dataclass\n",
    "class V:\n",
    "    ciudad: str\n",
    "    monto: float\n",
    "\n",
    "como_dict = [{'ciudad': 'Lima', 'monto': 480.37},\n",
    "             {'ciudad': 'Cusco', 'monto': 154.83}]\n",
    "como_obj = [V('Lima', 480.37), V('Cusco', 154.83)]\n",
    "\n",
    "print(round(sum(d['monto'] for d in como_dict), 2))\n",
    "print(round(sum(o.monto for o in como_obj), 2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "635.2\n",
    "635.2\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mismo resultado. Para dos ventas el diccionario sobra; la clase empieza a\n",
    "ganar cuando además necesitas métodos, y pandas les gana a las dos en cuanto son\n",
    "más de cien filas."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 9. Dos clientes que deberían ser el mismo\n",
    "\n",
    "Quita los duplicados de una lista de clientes. Con una\n",
    "clase normal no se puede; con dataclass sí, y hace falta una línea más."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "@dataclass(frozen=True)\n",
    "class ClienteUnico:\n",
    "    nombre: str\n",
    "    segmento: str\n",
    "\n",
    "lista = [ClienteUnico('Rosita', 'Bodega'),\n",
    "         ClienteUnico('Distribuidora Lima', 'Mayorista'),\n",
    "         ClienteUnico('Rosita', 'Bodega')]\n",
    "\n",
    "print('en la lista:', len(lista))\n",
    "print('sin repetir :', len(set(lista)))\n",
    "for c in sorted(set(lista), key=lambda c: c.nombre):\n",
    "    print(' ', c.nombre)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "en la lista: 3\n",
    "sin repetir : 2\n",
    "  Distribuidora Lima\n",
    "  Rosita\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ese `frozen=True` es lo que hace que se pueda meter en un\n",
    "conjunto. Congela el objeto: una vez creado no se le cambia nada 🧊\n",
    "\n",
    "Y tiene lógica: un conjunto necesita poder calcular una huella de cada\n",
    "elemento, y esa huella no puede cambiar debajo. Por eso las listas no se pueden\n",
    "meter en un conjunto y las tuplas sí."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 10. Una clase que se defiende sola\n",
    "\n",
    "Haz que la clase compruebe sus propios datos al crearse,\n",
    "en vez de confiar en quien la llama."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "@dataclass\n",
    "class Venta:\n",
    "    cliente: str\n",
    "    monto: float\n",
    "    unidades: int\n",
    "\n",
    "    def __post_init__(self):\n",
    "        if self.monto < 0:\n",
    "            raise ValueError(f'monto negativo: {self.monto}')\n",
    "        if self.unidades <= 0:\n",
    "            raise ValueError(f'unidades tiene que ser mayor que cero: {self.unidades}')\n",
    "\n",
    "    @property\n",
    "    def precio_unitario(self):\n",
    "        return self.monto / self.unidades\n",
    "\n",
    "v = Venta('Rosita', 340.0, 4)\n",
    "print('precio por unidad:', round(v.precio_unitario, 2))\n",
    "\n",
    "try:\n",
    "    Venta('Rosita', -50.0, 4)\n",
    "except ValueError as e:\n",
    "    print('rechazada:', e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "precio por unidad: 85.0\n",
    "rechazada: monto negativo: -50.0\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dos cosas nuevas aquí, y las dos se usan muchísimo 💛\n",
    "\n",
    "`__post_init__` corre justo después de crear el objeto, y es donde\n",
    "va la comprobación. Un dato imposible se rechaza **al entrar**, no\n",
    "tres pantallas más abajo cuando ya nadie sabe de dónde salió.\n",
    "\n",
    "`@property` hace que `precio_unitario` se lea como un\n",
    "atributo (sin paréntesis) aunque por dentro sea un cálculo. Así nunca puede\n",
    "quedar desactualizado, porque no se guarda: se calcula cada vez que lo pides 🔄"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## La lista que todos tus clientes comparten sin saberlo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Antes de cerrar, la trampa de clases por excelencia. Funciona perfecto mientras pruebas con un objeto, y por eso llega tan lejos antes de que alguien la vea 😳"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### La trampa\n",
    "\n",
    "Creas una clase para tus clientes con una lista de compras dentro, que es lo natural. Registras una compra de Ana y miras a Beto.\n",
    "\n",
    "```\n",
    "class Cliente:\n",
    "    compras = []\n",
    "\n",
    "    def __init__(self, nombre):\n",
    "        self.nombre = nombre\n",
    "\n",
    "ana = Cliente('Ana')\n",
    "beto = Cliente('Beto')\n",
    "ana.compras.append('arroz')\n",
    "\n",
    "print(beto.compras)   # ['arroz']\n",
    "```\n",
    "\n",
    "**Qué está mal**\n",
    "\n",
    "Beto compró arroz sin enterarse 😳 Esa lista está escrita en el cuerpo de la clase, o sea que pertenece a **la clase** y no a cada cliente. Hay una sola lista y todos los clientes la comparten.\n",
    "\n",
    "El error tarda en aparecer porque con un solo cliente funciona perfecto. Sale cuando hay dos, y para entonces ya hay código encima que lo da por bueno.\n",
    "\n",
    "Lo que es de cada objeto se crea **dentro de `__init__`**: `self.compras = []`. En el cuerpo de la clase solo van las cosas que de verdad son iguales para todos, como una constante. Y con `dataclass` pasa lo mismo, por eso existe `field(default_factory=list)`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Comprueba que lo tienes\n",
    "\n",
    "¿Cuándo te conviene escribir una clase en un proyecto de datos?\n",
    "\n",
    "a) Cuando tienes datos y funciones que van siempre juntos\n",
    "\n",
    "b) Siempre, porque es la forma profesional de programar\n",
    "\n",
    "c) Cuando el archivo pasa de doscientas líneas\n",
    "\n",
    "d) Nunca, en análisis de datos no hacen falta\n",
    "\n",
    "---\n",
    "\n",
    "**La correcta es la a.**\n",
    "\n",
    "*b)* Un montón de código de datos excelente no tiene ni una clase.\n",
    "\n",
    "*c)* El tamaño no decide eso: decide si conviene partirlo en módulos.\n",
    "\n",
    "*d)* Las usas todo el rato sin escribirlas: un DataFrame es una.\n",
    "\n",
    "Una clase junta estado y comportamiento. Si no hay estado, con una función basta."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lo que te llevas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 🔵 En Python casi todo es un objeto, y por eso todo se usa con puntos.\n",
    "\n",
    "- 📊 Atributo sin paréntesis, método con paréntesis.\n",
    "\n",
    "- 🔎 Si tu salida dice \"method\", te faltaron los paréntesis.\n",
    "\n",
    "- 👉 `self` es este objeto, va primero en cada método y no se pasa\n",
    "al llamar.\n",
    "\n",
    "- ⚡ `@dataclass` te escribe el `__init__` y el\n",
    "`__repr__`.\n",
    "\n",
    "- 🤏 Antes de crear una clase, pregúntate si un diccionario o una función\n",
    "bastan. Casi siempre bastan.\n",
    "\n",
    "Y si de todo el capítulo te llevas una sola frase, que sea esta:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para datos hace falta entender objetos, no diseñarlos."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Eso de rechazar un dato imposible al entrar, en vez de descubrirlo tres\n",
    "pantallas más abajo, en una base de datos tiene nombre y se llama\n",
    "restricción. Está en el [libro de SQL](https://missyera.com/guias/sql-desde-cero/),\n",
    "y es la misma idea escrita en otro sitio 🛡️\n",
    "\n",
    "En el capítulo 10 abrimos archivos de verdad: CSV, Excel, JSON, y la\n",
    "codificación, que es la razón por la que a veces ves \"á\" donde debería haber una\n",
    "á.\n",
    "\n",
    "Que tengas lindo día! 🌸"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "Ese era el capítulo 9 de **Python desde cero**. El texto completo, con las salidas de cada bloque, está en https://missyera.com/guias/python-desde-cero/objetos/\n",
    "\n",
    "Que tengas lindo día! 🌸"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "name": "python",
   "version": "3.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}