Programación-Python/Cuadernos/py_0130_Patrones_POO.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "# <span style=\"color:#F72585\"><center>Patrones para Programación orientada a Objetos en Python</center> </span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<figure>\n",
    "<center>\n",
    "<img src=\"https://raw.githubusercontent.com/AprendizajeProfundo/Alejandria/main/Archivos_Generales/Imagenes/Patrones.jpg\" width=\"600\" height=\"400\" align=\"center\" /> \n",
    "</center>   \n",
    "</figure>\n",
    "<center>\n",
    "\n",
    "Fuente: [Pexels: Iva Muškić](https://www.pexels.com/es-es/foto/textil-estampado-colmena-gris-y-negro-691710/)\n",
    "\n",
    "</center>\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <span style=\"color:blue\">Introducción</span> "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En esta lección hacemos una revisión técnica de las cosas que debemos tener en cuenta para diseñar clase más robustas. Esta revisión está basada en  la lectura de Medium por [Michal Oleszak](https://towardsdatascience.com/8-tips-for-object-oriented-programming-in-python-3e98b767ae79)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <span style=\"color:blue\">Ocho consejos para crear mejores clases</span> "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Existe una gran diferencia entre diseñar un objeto que simplemente funcione y escribir un código de calidad que aproveche al máximo los beneficios del enfoque de programación orientada a objetos (POO). En esta sección revisamos ocho pasos que conducen a las clases de Python de buena calidad. Estos pasos son:\n",
    "\n",
    "\n",
    "1. Establecer atributos en el constructor.\n",
    "1. Distinguir datos y métodos a nivel de clase y a nivel de instancia.\n",
    "1. Determina lo que es igual.\n",
    "1. Proporcionar representaciones de cadenas.\n",
    "1. Conocer lo que es estático.\n",
    "1. Decidir lo que es interno y privado.\n",
    "1. Establecer el acceso a los atributos.\n",
    "1. Utilizar cadenas de documentación.\n",
    "\n",
    "En Python, los objetos se definen por sus planos llamados clases . Los atributos de clase se representan como variables de Python y sus métodos son funciones de Python. Consideraremos la siguiente clase de ejemplo de juguete que representa una cuenta bancaria."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class CuentaBancaria:\n",
    "    def set_cliente(self, cliente):\n",
    "        self.cliente = cliente\n",
    "        \n",
    "    def set_saldo(self, saldo):\n",
    "        self.saldo = saldo\n",
    "        \n",
    "    def deposito(self, monto):\n",
    "        self.saldo += monto\n",
    "        \n",
    "    def retiro(self, monto):\n",
    "        self.saldo -= monto"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La clase dispone de cuatro métodos, permitiéndonos configurar el titular (cliente) de la cuenta o depositar dinero, entre otros. Una vez que establecemos el *cliente*  crea el atributo. Esta clase podría considerarse completamente funcional, en el sentido de que podemos trabajar con ella. Puedo crear una cuenta para mí sin dinero en efectivo y hacer algunas transacciones:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "María 700\n"
     ]
    }
   ],
   "source": [
    "# primeras transacciones\n",
    "# crea instancia de CuentaBancaria\n",
    "mi_cuenta = CuentaBancaria()\n",
    "# Configura el cliente y el saldo inicial\n",
    "mi_cuenta.set_cliente(\"María\")\n",
    "mi_cuenta.set_saldo(0)\n",
    "\n",
    "# dos transacciones\n",
    "mi_cuenta.deposito(1000)\n",
    "mi_cuenta.retiro(300)\n",
    "\n",
    "print(mi_cuenta.cliente, mi_cuenta.saldo)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Este código aunque funcional está bastante mal escrito. Veamos como escribir el código correctamente. Por ejemplo, se podría intentar hacer las transacciones sin crear el saldo inicial, lo cual llevaría a un error. Observe el siguiente código."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'CuentaBancaria' object has no attribute 'saldo'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "Cell \u001b[0;32mIn [5], line 2\u001b[0m\n\u001b[1;32m      1\u001b[0m cuenta \u001b[38;5;241m=\u001b[39m CuentaBancaria()\n\u001b[0;32m----> 2\u001b[0m \u001b[43mcuenta\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdeposito\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m100\u001b[39;49m\u001b[43m)\u001b[49m\n",
      "Cell \u001b[0;32mIn [3], line 9\u001b[0m, in \u001b[0;36mCuentaBancaria.deposito\u001b[0;34m(self, monto)\u001b[0m\n\u001b[1;32m      8\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mdeposito\u001b[39m(\u001b[38;5;28mself\u001b[39m, monto):\n\u001b[0;32m----> 9\u001b[0m     \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39msaldo \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m monto\n",
      "\u001b[0;31mAttributeError\u001b[0m: 'CuentaBancaria' object has no attribute 'saldo'"
     ]
    }
   ],
   "source": [
    "cuenta = CuentaBancaria()\n",
    "cuenta.deposito(100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <span style=\"color:blue\">Patrón 1. Establecer atributos en el constructor</span> "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El primer consejo es: `establezca atributos en el constructor para asegurarse de que existan y se puedan encontrar fácilmente en un solo lugar`. Recuerde que el constructor se define con la función `__init__()`. Realmente existe una forma de definir constructores alternativos que sobrecargan a la función `__init__()`, como veremos en la siguiente sección. Para definir constructores alternativos usaremos métodos de clase, no estudiados  en la lección sobre [programación orientada a objetos](py_0110_POO.ipynb). A continuación implementamos el patron 1 en la clase *CuentaBancaria*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "from datetime import datetime\n",
    "\n",
    "class CuentaBancaria:\n",
    "    def __init__(self, cliente, numero_cuenta, saldo=0):\n",
    "        self.cliente = cliente    \n",
    "        self.numero_cuenta = numero_cuenta\n",
    "        self.creada_en = datetime.now().date()\n",
    "        if saldo < -10_000:\n",
    "            raise ValueError(\"¡Saldo muy pequeño!\")\n",
    "        else:\n",
    "            self.saldo = saldo\n",
    "    \n",
    "    def deposito(self, monto):\n",
    "        self.saldo += monto\n",
    "        \n",
    "    def retiro(self, monto):\n",
    "        self.saldo -= monto"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El valor de *saldo* es definido por defecto. Además se ha agregado un control que genera un error si se intenta crea una cuenta con un saldo muy negativo. A continuación instanciamos un objeto e imprimimos sus atributos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "María 151348 0 2022-08-14\n"
     ]
    }
   ],
   "source": [
    "# Crea un objeto con saldo inicial = 0\n",
    "mi_cuenta = CuentaBancaria('María', 151348)\n",
    "\n",
    "print(mi_cuenta.cliente, mi_cuenta.numero_cuenta, mi_cuenta.saldo, mi_cuenta.creada_en)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <span style=\"color:blue\"> Patrón 2. Distinguir atributos y métodos a nivel de clase y a nivel de instancia</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En la POO algunos atributos y métodos son por naturaleza inherentes a la clase en general, mientras que otros son específicos de las instancias de esta clase. Hacer una distinción entre los dos es vital para asegurarse de que la cuenta bancaria de un individuo no cambie la forma en que funcionan las cuentas bancarias en general.\n",
    "\n",
    "En esta lección solamente hemos definidos atributos y métodos inherentes a las instancias de clase. Los métodos de nivel de clase son útiles, entre otros, para crear objetos de clase a partir de fuentes externas, como archivos csv. Los métodos de clase permiten por ejemplo crear constructores alternativos para los objetos (instancias de clase)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### <span style=\"color:#4CC9F0\">Definiendo un método de clase para crear un objeto con información en un archivo</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Es posible crear métodos de clase en Python, que usan un apuntador usualmente llamado `cls` en lugar de `self`, que apunta a donde esta definida la clase, es decir, no necesitan una instancia para existir. \n",
    "\n",
    "Tenga en cuenta el siguiente convenio de facto.\n",
    "\n",
    "* El apuntador *cls* apuntará al sitio de memoria en donde está ubicada la clase.\n",
    "* El apuntador *self* apuntará al sitio de memoria en donde está ubicada la instancia (objeto).\n",
    "\n",
    "\n",
    "\n",
    "Un caso de uso popular es crear una instancia a partir de fuentes externas. Es posible que deseemos tener un método que cree una instancia de `CuentaBancaria` a partir de un archivo CSV que contenga por ejemplo el cliente y el número de cuenta en el formato separado por comas, como por ejemplo \n",
    "\n",
    "* María, 123\n",
    "\n",
    "Para hacerlo, podemos agregar un método que llamaremos por ejemplo *from_csv()*. Lo decoramos con el decorador `@classmethod` y usamos la referencia de clase, *cls*, como primer argumento. Podemos usarlo en la declaración de devolución para hacer que el método devuelva la instancia de la clase en función del contenido del archivo CSV. \n",
    "\n",
    "En cuanto a los atributos, el umbral de saldo -10000, con el que se compara el saldo al crear la cuenta puede pensarse como un atributo de clase.\n",
    "\n",
    "\n",
    "La clase CuentaBancaria modificada quedaría como que hay una regla que establece que no se puede configurar ninguna cuenta con un saldo más bajo. En lugar de codificarlo, deberíamos asignarlo a un atributo en la definición de la clase y acceder más tarde  a través del puntero de instancia `self`. Estos atributos de clase se definen al comienzo de la clase. Tenga en cuenta que el valor contenido en los atributos de clase son comunes a todas la instancias de clase.\n",
    "\n",
    "Los demás métodos y atributos ya incluidos arriba pertenece  a cada instancia particular y son en consecuencia atributos de instancia de clase, que ya aprendimos a crear antes en esta lección.\n",
    "\n",
    "\n",
    "La clase *CuentaBancaria* actualizada con los métodos y atributos de clase propuestos en esta sección es como sigue."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "from datetime import datetime\n",
    "import csv\n",
    "\n",
    "class CuentaBancaria:\n",
    "\n",
    "    MIN_SALDO = -10_000\n",
    "    \n",
    "    def __init__(self, cliente, numero_cuenta, saldo=0):\n",
    "        self.cliente = cliente    \n",
    "        self.numero_cuenta = numero_cuenta\n",
    "        self.creada_en = datetime.now().date()\n",
    "        if saldo < self.MIN_SALDO:\n",
    "            raise ValueError(\"¡Saldo muy pequeño!\")\n",
    "        else:\n",
    "            self.saldo = saldo\n",
    "    \n",
    "    @classmethod\n",
    "    def from_csv(cls, filepath):\n",
    "        with open(filepath, \"r\") as f:\n",
    "            fila = csv.reader(f).__next__()\n",
    "            cliente, numero_cuenta = fila\n",
    "            return cls(cliente, numero_cuenta)\n",
    "     \n",
    "    def deposito(self, monto):\n",
    "        self.saldo += monto\n",
    "        \n",
    "    def retiro(self, monto):\n",
    "        self.saldo -= monto\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Probamos la clase."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "María 151148 0 2022-10-21\n"
     ]
    }
   ],
   "source": [
    "# usando el método de clase\n",
    "path = '../Datos/cuenta.csv'\n",
    "mi_cuenta = CuentaBancaria.from_csv(path)\n",
    "print(mi_cuenta.cliente, mi_cuenta.numero_cuenta, mi_cuenta.saldo, mi_cuenta.creada_en)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "María 151348 0 2022-10-21\n"
     ]
    }
   ],
   "source": [
    "# usando el constructor __init__\n",
    "mi_cuenta = CuentaBancaria('María', 151348)\n",
    "print(mi_cuenta.cliente, mi_cuenta.numero_cuenta, mi_cuenta.saldo, mi_cuenta.creada_en)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <span style=\"color:blue\">Patron 3: Implementar igualdad de objetos</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La comparación de instancias de clase es una tarea habitual, cuya implementación no es inmediata. Observe el siguiente ejemplo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cuenta_A = CuentaBancaria(\"María\", 151148)\n",
    "cuenta_B = CuentaBancaria(\"María\", 151148)\n",
    "\n",
    "cuenta_A == cuenta_B"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Las dos cuentas tiene el mismo contenido, pero la comparación es False. Esto sucede porque cuando Python compara en realidad los fragmentos de memoria que ocupan las instancias.\n",
    "\n",
    "Para implementar la comparación de instancias de clase usamos la función especial `__eq__`. Veamos un ejemplo de implementación en nuestra clase *CuentaBancaria*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "from datetime import datetime\n",
    "import csv\n",
    "\n",
    "class CuentaBancaria:\n",
    "\n",
    "    MIN_SALDO = -10_000\n",
    "    \n",
    "    def __init__(self, cliente, numero_cuenta, saldo=0):\n",
    "        self.cliente = cliente    \n",
    "        self.numero_cuenta = numero_cuenta\n",
    "        self.creada_en = datetime.now().date()\n",
    "        if saldo < self.MIN_SALDO:\n",
    "            raise ValueError(\"¡Saldo muy pequeño!\")\n",
    "        else:\n",
    "            self.saldo = saldo\n",
    "    \n",
    "    @classmethod\n",
    "    def from_csv(cls, filepath):\n",
    "        with open(filepath, \"r\") as f:\n",
    "            fila = csv.reader(f).__next__()\n",
    "            cliente, numero_cuenta = fila\n",
    "            return cls(cliente, numero_cuenta)\n",
    "     \n",
    "    def deposito(self, monto):\n",
    "        self.saldo += monto\n",
    "        \n",
    "    def retiro(self, monto):\n",
    "        self.saldo -= monto\n",
    "    \n",
    "    def __eq__(self, other):\n",
    "        return True if self.numero_cuenta == other.numero_cuenta else False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Probamos de nuevo\n",
    "cuenta_A = CuentaBancaria(\"María\", 151148)\n",
    "cuenta_B = CuentaBancaria(\"María\", 151148)\n",
    "\n",
    "cuenta_A == cuenta_B"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "De igual manera es posible implementar las comparaciones mayor que `__gt__`, menor o igual a `__le__`, etc. Veamos un ejemplo. Vamos a comparar las cuentas por el saldo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "from datetime import datetime\n",
    "import csv\n",
    "\n",
    "class CuentaBancaria:\n",
    "\n",
    "    MIN_SALDO = -10_000\n",
    "    \n",
    "    def __init__(self, cliente, numero_cuenta, saldo=0):\n",
    "        self.cliente = cliente    \n",
    "        self.numero_cuenta = numero_cuenta\n",
    "        self.creada_en = datetime.now().date()\n",
    "        if saldo < self.MIN_SALDO:\n",
    "            raise ValueError(\"¡Saldo muy pequeño!\")\n",
    "        else:\n",
    "            self.saldo = saldo\n",
    "    \n",
    "    @classmethod\n",
    "    def from_csv(cls, filepath):\n",
    "        with open(filepath, \"r\") as f:\n",
    "            fila = csv.reader(f).__next__()\n",
    "            cliente, numero_cuenta = fila\n",
    "            return cls(cliente, numero_cuenta)\n",
    "     \n",
    "    def deposito(self, monto):\n",
    "        self.saldo += monto\n",
    "        \n",
    "    def retiro(self, monto):\n",
    "        self.saldo -= monto\n",
    "    \n",
    "    def __eq__(self, other):\n",
    "        return True if self.numero_cuenta == other.numero_cuenta else False\n",
    "    \n",
    "    def __gt__(self, other):\n",
    "        return True if self.saldo > other.saldo else False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# probamos\n",
    "cuenta_A = CuentaBancaria(\"María\", 151148, 1000)\n",
    "cuenta_B = CuentaBancaria(\"Luis\", 151050, 500)\n",
    "\n",
    "print(cuenta_A == cuenta_B)\n",
    "print(cuenta_A > cuenta_B)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <span style=\"color:blue\">Patrón 4. Implementar una representación de instancias de clase en forma de cadena</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para tener una representación de las instancia en forma de texto, fácil de revisar por parte del usuario, implemente el método especial `__repr__`. Esto permite depurar más fácilmente nuestros objetos, porque es una representación más legible para los humanos. Veamos el ejemplo. Vamos a implementar además el método especial `__str__` que ya estudiamos antes para tener una versión de *print* comprensible para los humanos. Agregamos además una función auxiliar a nuestra clase para manejar las fechas de análisis. Hablaremos más sobre esto más adelante."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "from datetime import datetime\n",
    "import csv\n",
    "\n",
    "class CuentaBancaria:\n",
    "\n",
    "    MIN_SALDO = -10_000\n",
    "    \n",
    "    def __init__(self, cliente, numero_cuenta, saldo=0):\n",
    "        self.cliente = cliente    \n",
    "        self.numero_cuenta = numero_cuenta\n",
    "        self.creada_en = datetime.now().date()\n",
    "        if saldo < self.MIN_SALDO:\n",
    "            raise ValueError(\"¡Saldo muy pequeño!\")\n",
    "        else:\n",
    "            self.saldo = saldo\n",
    "    \n",
    "    @classmethod\n",
    "    def from_csv(cls, filepath):\n",
    "        with open(filepath, \"r\") as f:\n",
    "            fila = csv.reader(f).__next__()\n",
    "            cliente, numero_cuenta = fila\n",
    "            return cls(cliente, numero_cuenta)\n",
    "     \n",
    "    def deposito(self, monto):\n",
    "        self.saldo += monto\n",
    "        \n",
    "    def retiro(self, monto):\n",
    "        self.saldo -= monto\n",
    "    \n",
    "    def __eq__(self, other):\n",
    "        return True if self.numero_cuenta == other.numero_cuenta else False\n",
    "    \n",
    "    def __str__(self):\n",
    "        return f\"\"\"\n",
    "          Cuenta Bancaria:\n",
    "          Propietario de la cuenta: {self.cliente}\n",
    "          Número de cuenta: {self.numero_cuenta}\n",
    "          Fecha de creación: {self.to_dash_date(str(self.creada_en))}\n",
    "          Saldo actual: {self.saldo}\n",
    "          \"\"\"\n",
    "    \n",
    "    def to_dash_date(self, date):\n",
    "        return date.replace(\"/\", \"-\")\n",
    "    \n",
    "    def __repr__(self):\n",
    "        return f\"CuentaBancaria(cliente='{self.cliente}', \" \\\n",
    "               f\"numero_cuenta={self.numero_cuenta}, \" \\\n",
    "               f\"saldo={self.saldo})\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Este es el resultado."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "          Cuenta Bancaria:\n",
      "          Propietario de la cuenta: María\n",
      "          Número de cuenta: 151148\n",
      "          Fecha de creación: 2022-08-16\n",
      "          Saldo actual: 0\n",
      "          \n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "\"CuentaBancaria(cliente='María', numero_cuenta=151148, saldo=0)\""
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mi_cuenta = CuentaBancaria(\"María\", 151148)\n",
    "print(mi_cuenta)\n",
    "repr(mi_cuenta)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <span style=\"color:blue\">Patrón 5. Marcar métodos estáticos</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Un método se considera estático cuando no requiere transformar atributos dentro de la instancia o no utiliza métodos de la instancia. En ejemplo anteiror la función utilitaria *to_dash_date* recibe la fecha de creación solamente para mostrala en un formato mas adecuado para los humanos. Esta método es estático y vamos a marcarlo como tal. Esto ahorra memoria y lo hace más eficiente. Observe que ahora no pasamos el apuntador *cls* a la método."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "from datetime import datetime\n",
    "import csv\n",
    "\n",
    "class CuentaBancaria:\n",
    "\n",
    "    MIN_SALDO = -10_000\n",
    "    \n",
    "    def __init__(self, cliente, numero_cuenta, saldo=0):\n",
    "        self.cliente = cliente    \n",
    "        self.numero_cuenta = numero_cuenta\n",
    "        self.creada_en = datetime.now().date()\n",
    "        if saldo < self.MIN_SALDO:\n",
    "            raise ValueError(\"¡Saldo muy pequeño!\")\n",
    "        else:\n",
    "            self.saldo = saldo\n",
    "    \n",
    "    @classmethod\n",
    "    def from_csv(cls, filepath):\n",
    "        with open(filepath, \"r\") as f:\n",
    "            fila = csv.reader(f).__next__()\n",
    "            cliente, numero_cuenta = fila\n",
    "            return cls(cliente, numero_cuenta)\n",
    "     \n",
    "    def deposito(self, monto):\n",
    "        self.saldo += monto\n",
    "        \n",
    "    def retiro(self, monto):\n",
    "        self.saldo -= monto\n",
    "    \n",
    "    def __eq__(self, other):\n",
    "        return True if self.numero_cuenta == other.numero_cuenta else False\n",
    "    \n",
    "    def __str__(self):\n",
    "        return f\"\"\"\n",
    "          Cuenta Bancaria:\n",
    "          Propietario de la cuenta: {self.cliente}\n",
    "          Número de cuenta: {self.numero_cuenta}\n",
    "          Fecha de creación: {self.to_dash_date(str(self.creada_en))}\n",
    "          Saldo actual: {self.saldo}\n",
    "          \"\"\"\n",
    "    \n",
    "    @staticmethod\n",
    "    def to_dash_date(date):\n",
    "        return date.replace(\"/\", \"-\")\n",
    "    \n",
    "    def __repr__(self):\n",
    "        return f\"CuentaBancaria(cliente='{self.cliente}', \" \\\n",
    "               f\"numero_cuenta={self.numero_cuenta}, \" \\\n",
    "               f\"saldo={self.saldo})\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Este es el resultado. El mismo de antes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "          Cuenta Bancaria:\n",
      "          Propietario de la cuenta: María\n",
      "          Número de cuenta: 151148\n",
      "          Fecha de creación: 2022-08-16\n",
      "          Saldo actual: 0\n",
      "          \n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "\"CuentaBancaria(cliente='María', numero_cuenta=151148, saldo=0)\""
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mi_cuenta = CuentaBancaria(\"María\", 151148)\n",
    "print(mi_cuenta)\n",
    "repr(mi_cuenta)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <span style=\"color:blue\">Patrón 6. Decidir que es interno y que es privado</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Algunos métodos y atributos en cualquier clase están destinados a ser utilizados explícitamente por el usuario del código, como los métodos *retiro()* y *deposito()*en nuestra clase *CuentaBancaria*. Algunos, sin embargo, no lo son. El método *_dash_date()* es una utilidad de ayuda llamada por la clase bajo el capó, pero no está pensada para ser llamada manualmente. \n",
    "\n",
    "Dichos métodos y atributos se conocen como  `métodos y atributos internos` y es la mejor práctica comenzar sus nombres con un guión bajo para que tengamos *_to_dash_date()*, y por ejemplo *self._cliente* Y *self._saldo*, si así se decide.\n",
    "\n",
    "Esta convención de nomenclatura por sí misma no hace nada, pero permite que las personas que miran su código reconozcan de inmediato qué métodos no forman parte de la API pública y, por lo tanto, pueden cambiar inesperadamente en futuras versiones del código.\n",
    "\n",
    "Un tema relacionado son los`métodos y atributos privados` . Es posible que desee ocultar algunos métodos o atributos del mundo exterior, por ejemplo, para asegurarse de que no se sobrescriban. En Python, no existe un mecanismo para ocultarlos por completo, pero podemos marcarlos como privados nombrándolos con un doble guión bajo inicial. Por ejemplo, podríamos querer que el umbral de saldo mínimo sea privado, por lo que lo llamamos `__MIN_SALDO`.\n",
    "\n",
    "Ahora, aunque es accesible dentro de la clase como de costumbre, la llamada `mi_cuencta.__MIN_SALDO` generará una excepción. Esto significa para el usuario que este atributo es privado y no debe ser manipulado.\n",
    "\n",
    "Con estas consideraciones, nuestra clase toma la forma"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "from datetime import datetime\n",
    "import csv\n",
    "\n",
    "class CuentaBancaria:\n",
    "\n",
    "    __MIN_SALDO = -10_000\n",
    "    \n",
    "    def __init__(self, cliente, numero_cuenta, saldo=0):\n",
    "        self._cliente = cliente    \n",
    "        self.numero_cuenta = numero_cuenta\n",
    "        self.creada_en = datetime.now().date()\n",
    "        if saldo < self.__MIN_SALDO:\n",
    "            raise ValueError(\"¡Saldo muy pequeño!\")\n",
    "        else:\n",
    "            self._saldo = saldo\n",
    "    \n",
    "    @classmethod\n",
    "    def from_csv(cls, filepath):\n",
    "        with open(filepath, \"r\") as f:\n",
    "            fila = csv.reader(f).__next__()\n",
    "            cliente, numero_cuenta = fila\n",
    "            return cls(cliente, numero_cuenta)\n",
    "     \n",
    "    def deposito(self, monto):\n",
    "        self.saldo += monto\n",
    "        \n",
    "    def retiro(self, monto):\n",
    "        self.saldo -= monto\n",
    "    \n",
    "    def __eq__(self, other):\n",
    "        return True if self.numero_cuenta == other.numero_cuenta else False\n",
    "    \n",
    "    def __str__(self):\n",
    "        return f\"\"\"\n",
    "          Cuenta Bancaria:\n",
    "          Propietario de la cuenta: {self._cliente}\n",
    "          Número de cuenta: {self.numero_cuenta}\n",
    "          Fecha de creación: {self._to_dash_date(str(self.creada_en))}\n",
    "          Saldo actual: {self._saldo}\n",
    "          \"\"\"\n",
    "    \n",
    "    @staticmethod\n",
    "    def _to_dash_date(date):\n",
    "        return date.replace(\"/\", \"-\")\n",
    "    \n",
    "    def __repr__(self):\n",
    "        return f\"CuentaBancaria(cliente='{self._cliente}', \" \\\n",
    "               f\"numero_cuenta={self.numero_cuenta}, \" \\\n",
    "               f\"saldo={self._saldo})\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El resultado es el siguiente. Observe que ahora *\\_\\_MIN_SALDO* no es accesible desde afuera del objeto."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "          Cuenta Bancaria:\n",
      "          Propietario de la cuenta: María\n",
      "          Número de cuenta: 151148\n",
      "          Fecha de creación: 2022-10-21\n",
      "          Saldo actual: 0\n",
      "          \n"
     ]
    },
    {
     "ename": "AttributeError",
     "evalue": "'CuentaBancaria' object has no attribute '__MIN_SALDO'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "Cell \u001b[0;32mIn [29], line 4\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[38;5;28mprint\u001b[39m(mi_cuenta)\n\u001b[1;32m      3\u001b[0m \u001b[38;5;28mrepr\u001b[39m(mi_cuenta)\n\u001b[0;32m----> 4\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[43mmi_cuenta\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m__MIN_SALDO\u001b[49m)\n",
      "\u001b[0;31mAttributeError\u001b[0m: 'CuentaBancaria' object has no attribute '__MIN_SALDO'"
     ]
    }
   ],
   "source": [
    "mi_cuenta = CuentaBancaria(\"María\", 151148)\n",
    "print(mi_cuenta)\n",
    "repr(mi_cuenta)\n",
    "print(mi_cuenta.__MIN_SALDO)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <span style=\"color:blue\">Patrón 7. Establecer el acceso a los atributos: `@property`</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Consideremos el siguiente fragmento de código:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "          Cuenta Bancaria:\n",
      "          Propietario de la cuenta: María\n",
      "          Número de cuenta: 151148\n",
      "          Fecha de creación: 1900-01-01 00:00:00\n",
      "          Saldo actual: -999999\n",
      "          \n"
     ]
    }
   ],
   "source": [
    "mi_cuenta = CuentaBancaria(\"María\", 151148)\n",
    "mi_cuenta._saldo = -999_999\n",
    "mi_cuenta.creada_en = datetime(1900,1,1)\n",
    "print(mi_cuenta)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como puede ver, es bastante fácil cambiar la fecha de creación en una cuenta existente, así como establecer el saldo en un número negativo grande. \n",
    "\n",
    "Recuerde que la fecha de creación se establece automáticamente en la creación del objeto, y no podríamos configurar una cuenta con un saldo demasiado negativo gracias a la validación de entrada en el método `__init__()`\n",
    "\n",
    "¿Qué podemos hacer al respecto? Idealmente, la fecha de creación debe ser un atributo de solo lectura y el saldo debe tener alguna validación cada vez que se actualiza. Esto se puede lograr en Python usando propiedades y setters.\n",
    "\n",
    "\n",
    "Usaremos propiedades y configuradores para hacer que los atributos sean de solo lectura y validar sus actualizaciones.\n",
    "\n",
    "Para hacer, digamos, que el atributo saldo sea de solo lectura, todo lo que se necesitamos hacer es agregar una función a la clase llamada exactamente como este atributo decorado con un decorador `@property` y devolviendo el valor del atributo.\n",
    "\n",
    "Vamos al nuevo código de nuestra clase. Hemos declarado todos los atributos de instancia como internos y creado la propiedad saldo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [],
   "source": [
    "from datetime import datetime\n",
    "import csv\n",
    "\n",
    "class CuentaBancaria:\n",
    "\n",
    "    __MIN_SALDO = -10_000\n",
    "    \n",
    "    def __init__(self, cliente, numero_cuenta, saldo=0):\n",
    "        self._cliente = cliente    \n",
    "        self._numero_cuenta = numero_cuenta\n",
    "        self._creada_en = datetime.now().date()\n",
    "        if saldo < self.__MIN_SALDO:\n",
    "            raise ValueError(\"¡Saldo muy pequeño!\")\n",
    "        else:\n",
    "            self._saldo = saldo\n",
    "    \n",
    "    @classmethod\n",
    "    def from_csv(cls, filepath):\n",
    "        with open(filepath, \"r\") as f:\n",
    "            fila = csv.reader(f).__next__()\n",
    "            cliente, numero_cuenta = fila\n",
    "            return cls(cliente, numero_cuenta)\n",
    "     \n",
    "    def deposito(self, monto):\n",
    "        self._saldo += monto\n",
    "        \n",
    "    def retiro(self, monto):\n",
    "        self._saldo -= monto\n",
    "    \n",
    "    def __eq__(self, other):\n",
    "        return True if self.numero_cuenta == other.numero_cuenta else False\n",
    "    \n",
    "    def __str__(self):\n",
    "        return f\"\"\"\n",
    "          Cuenta Bancaria:\n",
    "          Propietario de la cuenta: {self._cliente}\n",
    "          Número de cuenta: {self._numero_cuenta}\n",
    "          Fecha de creación: {self._to_dash_date(str(self._creada_en))}\n",
    "          Saldo actual: {self._saldo}\n",
    "          \"\"\"\n",
    "    \n",
    "    @staticmethod\n",
    "    def _to_dash_date(date):\n",
    "        return date.replace(\"/\", \"-\")\n",
    "    \n",
    "    def __repr__(self):\n",
    "        return f\"CuentaBancaria(cliente='{self._cliente}', \" \\\n",
    "               f\"numero_cuenta={self._numero_cuenta}, \" \\\n",
    "               f\"saldo={self._saldo})\"\n",
    "    \n",
    "    @property\n",
    "    def numero_cuenta(self):\n",
    "        return self._numero_cuenta\n",
    "    \n",
    "    @property\n",
    "    def creada_en(self):\n",
    "        return self._creada_en\n",
    "    \n",
    "    @property\n",
    "    def saldo(self):\n",
    "        return self._saldo\n",
    "    \n",
    "    \n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Primero revisemos que nada del comportamiento externo anterior no cambió."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "          Cuenta Bancaria:\n",
      "          Propietario de la cuenta: María\n",
      "          Número de cuenta: 151148\n",
      "          Fecha de creación: 2022-08-16\n",
      "          Saldo actual: 0\n",
      "          \n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "\"CuentaBancaria(cliente='María', numero_cuenta=151148, saldo=0)\""
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mi_cuenta = CuentaBancaria(\"María\", 151148)\n",
    "print(mi_cuenta)\n",
    "repr(mi_cuenta)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pero ahora no funciona"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "can't set attribute",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-84-006ff73a9363>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mmi_cuenta\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msaldo\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m100\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m: can't set attribute"
     ]
    }
   ],
   "source": [
    "mi_cuenta.saldo = 100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Este funcionamiento estaría bien por ejemplo para número de cuenta y fecha de creación"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "151148"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mi_cuenta.numero_cuenta\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"CuentaBancaria(cliente='María', numero_cuenta=151148, saldo=0)\""
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "repr(mi_cuenta)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <span style=\"color:#4CC9F0\">Implementación de un setter</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En este momento no es posible actualizar el saldo desde el exterior del objeto. Para implementar la actualización usamos el método especial setter. Este método asociado a la propiedad `@saldo`  permite escribir la lógica para implementar la actualización correcta del saldo. Veamos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "from datetime import datetime\n",
    "import csv\n",
    "\n",
    "class CuentaBancaria:\n",
    "\n",
    "    __MIN_SALDO = -10_000\n",
    "    \n",
    "    def __init__(self, cliente, numero_cuenta, saldo=0):\n",
    "        self._cliente = cliente    \n",
    "        self._numero_cuenta = numero_cuenta\n",
    "        self._creada_en = datetime.now().date()\n",
    "        if saldo < self.__MIN_SALDO:\n",
    "            raise ValueError(\"¡Saldo muy pequeño!\")\n",
    "        else:\n",
    "            self._saldo = saldo\n",
    "    \n",
    "    @classmethod\n",
    "    def from_csv(cls, filepath):\n",
    "        with open(filepath, \"r\") as f:\n",
    "            fila = csv.reader(f).__next__()\n",
    "            cliente, numero_cuenta = fila\n",
    "            return cls(cliente, numero_cuenta)\n",
    "     \n",
    "    def deposito(self, monto):\n",
    "        self._saldo += monto\n",
    "        \n",
    "    def retiro(self, monto):\n",
    "        self._saldo -= monto\n",
    "    \n",
    "    def __eq__(self, other):\n",
    "        return True if self.numero_cuenta == other.numero_cuenta else False\n",
    "    \n",
    "    def __str__(self):\n",
    "        return f\"\"\"\n",
    "          Cuenta Bancaria:\n",
    "          Propietario de la cuenta: {self._cliente}\n",
    "          Número de cuenta: {self._numero_cuenta}\n",
    "          Fecha de creación: {self._to_dash_date(str(self._creada_en))}\n",
    "          Saldo actual: {self._saldo}\n",
    "          \"\"\"\n",
    "    \n",
    "    @staticmethod\n",
    "    def _to_dash_date(date):\n",
    "        return date.replace(\"/\", \"-\")\n",
    "    \n",
    "    def __repr__(self):\n",
    "        return f\"CuentaBancaria(cliente='{self._cliente}', \" \\\n",
    "               f\"numero_cuenta={self._numero_cuenta}, \" \\\n",
    "               f\"saldo={self._saldo})\"\n",
    "    \n",
    "    @property\n",
    "    def numero_cuenta(self):\n",
    "        return self._numero_cuenta\n",
    "    \n",
    "    @property\n",
    "    def creada_en(self):\n",
    "        return self._creada_en\n",
    "    \n",
    "    @property\n",
    "    def saldo(self):\n",
    "        return self._saldo\n",
    "    \n",
    "    @saldo.setter\n",
    "    def saldo(self, nuevo_saldo):\n",
    "        if nuevo_saldo < self.__MIN_SALDO:\n",
    "            raise ValueError(\"¡Saldo muy pequeño!\")\n",
    "        else:\n",
    "            self._saldo = nuevo_saldo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "          Cuenta Bancaria:\n",
      "          Propietario de la cuenta: María\n",
      "          Número de cuenta: 151148\n",
      "          Fecha de creación: 2022-10-21\n",
      "          Saldo actual: 0\n",
      "          \n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "\"CuentaBancaria(cliente='María', numero_cuenta=151148, saldo=0)\""
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mi_cuenta = CuentaBancaria(\"María\", 151148)\n",
    "print(mi_cuenta)\n",
    "repr(mi_cuenta)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "          Cuenta Bancaria:\n",
      "          Propietario de la cuenta: María\n",
      "          Número de cuenta: 151148\n",
      "          Fecha de creación: 2022-10-21\n",
      "          Saldo actual: 500\n",
      "          \n"
     ]
    }
   ],
   "source": [
    "mi_cuenta.saldo = 500\n",
    "print(mi_cuenta)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "¡Saldo muy pequeño!",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "Cell \u001b[0;32mIn [35], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mmi_cuenta\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msaldo\u001b[49m \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m15_000\u001b[39m\n\u001b[1;32m      2\u001b[0m \u001b[38;5;28mprint\u001b[39m(mi_cuenta)\n",
      "Cell \u001b[0;32mIn [32], line 66\u001b[0m, in \u001b[0;36mCuentaBancaria.saldo\u001b[0;34m(self, nuevo_saldo)\u001b[0m\n\u001b[1;32m     63\u001b[0m \u001b[38;5;129m@saldo\u001b[39m\u001b[38;5;241m.\u001b[39msetter\n\u001b[1;32m     64\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21msaldo\u001b[39m(\u001b[38;5;28mself\u001b[39m, nuevo_saldo):\n\u001b[1;32m     65\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m nuevo_saldo \u001b[38;5;241m<\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m__MIN_SALDO:\n\u001b[0;32m---> 66\u001b[0m         \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m¡Saldo muy pequeño!\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m     67\u001b[0m     \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m     68\u001b[0m         \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_saldo \u001b[38;5;241m=\u001b[39m nuevo_saldo\n",
      "\u001b[0;31mValueError\u001b[0m: ¡Saldo muy pequeño!"
     ]
    }
   ],
   "source": [
    "mi_cuenta.saldo = -15_000\n",
    "print(mi_cuenta)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <span style=\"color:blue\">Patrón 8. Documentar con cadenas de texto clases, métodos, atributos públicos</span>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Escriba cadenas de documentación para todos los módulos, funciones, clases y métodos públicos. Las cadenas de documentos no son necesarias para los métodos no públicos, pero debe tener un comentario que describa lo que hace el método. Este comentario debe aparecer después de la línea \"def\". Esta documentación aparece al pedir ayuda (help) de los objetos.\n",
    "\n",
    "Nuestra versión final de la clase *CuentaBancaria* es"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [],
   "source": [
    "from datetime import datetime\n",
    "import csv\n",
    "\n",
    "class CuentaBancaria:\n",
    "    \"\"\"\n",
    "    Clase CuentaBancaria:\n",
    "    Esta clase implementa la creación y moviemientos de una cuencta bancaria.\n",
    "    Atributos públicos:\n",
    "    \n",
    "    \"\"\"\n",
    "\n",
    "    __MIN_SALDO = -10_000\n",
    "    \n",
    "    def __init__(self, cliente, numero_cuenta, saldo=0):\n",
    "        \"\"\"\n",
    "        Este es el constructor por defecto de la clase CuentaBancaria\n",
    "        \"\"\"\n",
    "        self._cliente = cliente    \n",
    "        self._numero_cuenta = numero_cuenta\n",
    "        self._creada_en = datetime.now().date()\n",
    "        if saldo < self.__MIN_SALDO:\n",
    "            raise ValueError(\"¡Saldo muy pequeño!\")\n",
    "        else:\n",
    "            self._saldo = saldo\n",
    "    \n",
    "    @classmethod\n",
    "    def from_csv(cls, filepath):\n",
    "        with open(filepath, \"r\") as f:\n",
    "            fila = csv.reader(f).__next__()\n",
    "            cliente, numero_cuenta = fila\n",
    "            return cls(cliente, numero_cuenta)\n",
    "     \n",
    "    def deposito(self, monto):\n",
    "        self._saldo += monto\n",
    "        \n",
    "    def retiro(self, monto):\n",
    "        self._saldo -= monto\n",
    "    \n",
    "    def __eq__(self, other):\n",
    "        return True if self.numero_cuenta == other.numero_cuenta else False\n",
    "    \n",
    "    def __str__(self):\n",
    "        return f\"\"\"\n",
    "          Cuenta Bancaria:\n",
    "          Propietario de la cuenta: {self._cliente}\n",
    "          Número de cuenta: {self._numero_cuenta}\n",
    "          Fecha de creación: {self._to_dash_date(str(self._creada_en))}\n",
    "          Saldo actual: {self._saldo}\n",
    "          \"\"\"\n",
    "    \n",
    "    @staticmethod\n",
    "    def _to_dash_date(date):\n",
    "        return date.replace(\"/\", \"-\")\n",
    "    \n",
    "    def __repr__(self):\n",
    "        return f\"CuentaBancaria(cliente='{self._cliente}', \" \\\n",
    "               f\"numero_cuenta={self._numero_cuenta}, \" \\\n",
    "               f\"saldo={self._saldo})\"\n",
    "    \n",
    "    @property\n",
    "    def numero_cuenta(self):\n",
    "        return self._numero_cuenta\n",
    "    \n",
    "    @property\n",
    "    def creada_en(self):\n",
    "        return self._creada_en\n",
    "    \n",
    "    @property\n",
    "    def saldo(self):\n",
    "        return self._saldo\n",
    "    \n",
    "    @saldo.setter\n",
    "    def saldo(self, nuevo_saldo):\n",
    "        if nuevo_saldo < self.__MIN_SALDO:\n",
    "            raise ValueError(\"¡Saldo muy pequeño!\")\n",
    "        else:\n",
    "            self._saldo = nuevo_saldo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on class CuentaBancaria in module __main__:\n",
      "\n",
      "class CuentaBancaria(builtins.object)\n",
      " |  CuentaBancaria(cliente, numero_cuenta, saldo=0)\n",
      " |  \n",
      " |  Clase CuentaBancaria:\n",
      " |  Esta clase implementa la creación y moviemientos de una cuencta bancaria.\n",
      " |  Atributos públicos:\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  __eq__(self, other)\n",
      " |      Return self==value.\n",
      " |  \n",
      " |  __init__(self, cliente, numero_cuenta, saldo=0)\n",
      " |      Este es el constructor por defecto de la clase CuentaBancaria\n",
      " |  \n",
      " |  __repr__(self)\n",
      " |      Return repr(self).\n",
      " |  \n",
      " |  __str__(self)\n",
      " |      Return str(self).\n",
      " |  \n",
      " |  deposito(self, monto)\n",
      " |  \n",
      " |  retiro(self, monto)\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Class methods defined here:\n",
      " |  \n",
      " |  from_csv(filepath) from builtins.type\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Readonly properties defined here:\n",
      " |  \n",
      " |  creada_en\n",
      " |  \n",
      " |  numero_cuenta\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data descriptors defined here:\n",
      " |  \n",
      " |  __dict__\n",
      " |      dictionary for instance variables (if defined)\n",
      " |  \n",
      " |  __weakref__\n",
      " |      list of weak references to the object (if defined)\n",
      " |  \n",
      " |  saldo\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes defined here:\n",
      " |  \n",
      " |  __hash__ = None\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(CuentaBancaria)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <span style=\"color:blue\"> Ejercicios</span> "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Implemente una clase Persona que contenga la información general de una persona\n",
    "1. Diseñe una clase Estudiante que implemente el manejo de las notas de clase de un estudiante. Derive la clase de Persona. Suponga que el estudiante debe atender a tres cursos: Matemáticas, Español y Biología.\n",
    "1. Implemente el ingreso de notas: hasta 3 por curso.\n",
    "1. Implemente el cálculo de la nota definitiva, como un promedio de las notas.\n",
    "1. Use todos los patrones definidos en esta lección."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}