{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyMy0CVMdgzXDZfILnnxkLN3",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/financieras/pyCourse/blob/main/jupyter/calisto2/0045_atributos_ejemplo.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Ejemplo: atributos de clase y de instancia"
      ],
      "metadata": {
        "id": "r_FyFgu7gOtQ"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Clase `Prestamo`\n",
        " * El atributo de clase `tasa_interes` es común para todas las instancias de la clase `Prestamo`.\n",
        " * Los atributos `monto` y `plazo` son atributos de instancia, son específicos para cada instancia de la clase `Prestamo`.\n",
        " * La función `calcular_interes` es un método que calcula el interés del préstamo utilizando tanto el atributo de clase como los atributos de instancia."
      ],
      "metadata": {
        "id": "ZC-tWHcfgoMI"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mWUn0_iZgOB4",
        "outputId": "68da53dd-a86d-44df-834d-eba79c544681"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1000\n",
            "12\n",
            "0.005\n",
            "60.0\n"
          ]
        }
      ],
      "source": [
        "class Prestamo:\n",
        "    # Atributo de clase\n",
        "    tasa_interes = 0.005    # es un 0,5% mensual, lo que equivale a un TIN del 6% anual\n",
        "\n",
        "    def __init__(self, monto, plazo):\n",
        "        # Atributos de instancia\n",
        "        self.monto = monto\n",
        "        self.plazo = plazo\n",
        "\n",
        "    def calcular_interes(self):\n",
        "        interes = self.monto * self.plazo * Prestamo.tasa_interes\n",
        "        return interes\n",
        "\n",
        "# Crear una instancia de la clase Prestamo\n",
        "p = Prestamo(1000, 12)\n",
        "\n",
        "# Acceder a los atributos de instancia\n",
        "print(p.monto)  # Output: 1000\n",
        "print(p.plazo)  # Output: 12\n",
        "\n",
        "# Acceder al atributo de clase\n",
        "print(Prestamo.tasa_interes)  # Output: 0.005\n",
        "\n",
        "# Calcular el interés del préstamo\n",
        "interes = p.calcular_interes()\n",
        "print(interes)  # Output: 60.0"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Clase `Usuario`"
      ],
      "metadata": {
        "id": "thACv-GOtEWt"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Usuario:\n",
        "    # Atributo de clase\n",
        "    num_usuarios = 0\n",
        "\n",
        "    def __init__(self, nombre, edad):\n",
        "        # Atributos de instancia\n",
        "        self.nombre = nombre\n",
        "        self.edad = edad\n",
        "\n",
        "        # Incrementar el número de usuarios\n",
        "        Usuario.num_usuarios += 1\n",
        "\n",
        "    def saludar(self):\n",
        "        print(f\"Hola, mi nombre es {self.nombre} y tengo {self.edad} años.\")\n",
        "\n",
        "# Crear dos instancias de la clase Usuario\n",
        "u1 = Usuario(\"Juan\", 25)\n",
        "u2 = Usuario(\"María\", 30)\n",
        "\n",
        "# Acceder a los atributos de instancia\n",
        "print(u1.nombre)  # Output: Juan\n",
        "print(u2.edad)  # Output: 30\n",
        "\n",
        "# Acceder al atributo de clase\n",
        "print(Usuario.num_usuarios)  # Output: 2\n",
        "\n",
        "# Llamar al método saludar\n",
        "u1.saludar()  # Output: Hola, mi nombre es Juan y tengo 25 años.\n",
        "u2.saludar()  # Output: Hola, mi nombre es María y tengo 30 años."
      ],
      "metadata": {
        "id": "i9XcKU6ntPpp",
        "outputId": "4aaad9e9-5767-49c2-93d4-0d737a3bacb6",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Juan\n",
            "30\n",
            "2\n",
            "Hola, mi nombre es Juan y tengo 25 años.\n",
            "Hola, mi nombre es María y tengo 30 años.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Invocar a un método desde otro método"
      ],
      "metadata": {
        "id": "JrwOd-Fbwnz-"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Ejemplo:\n",
        "    def metodo1(self):\n",
        "        print(\"Este es el método 1.\")\n",
        "        self.metodo2()\n",
        "\n",
        "    def metodo2(self):\n",
        "        print(\"Este es el método 2.\")\n",
        "\n",
        "e = Ejemplo()\n",
        "e.metodo1()"
      ],
      "metadata": {
        "id": "EPlpOQnkwrje",
        "outputId": "dfb4b6fd-437b-4ce4-9822-96a065d446b4",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Este es el método 1.\n",
            "Este es el método 2.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Metaatributo ```__dict__```\n",
        "* El metaatributo `__dict__` es un diccionario que contiene los atributos de un objeto.\n",
        "* Este diccionario se puede utilizar para acceder a los atributos de un objeto y para agregar nuevos atributos."
      ],
      "metadata": {
        "id": "wsML-VyV1lMk"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "* En este ejemplo, creamos la clase `Laptop` con los atributos de instancia `marca` y `modelo`.\n",
        "* Se crea una instancia de la clase `Laptop` llamada `l`.\n",
        "* Se utiliza el metaatributo ```__dict__``` para acceder al diccionario de atributos del objeto y para agregar el nuevo atributo `pantalla`."
      ],
      "metadata": {
        "id": "qFkQgGQk4z9B"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Laptop:\n",
        "    # Atributos de clase\n",
        "    bateria = \"Integrada\"\n",
        "    conector = \"HDMI\"\n",
        "\n",
        "    def __init__(self, marca, modelo):\n",
        "        self.marca = marca\n",
        "        self.modelo = modelo\n",
        "\n",
        "l1 = Laptop(\"Lenovo\", \"ThinkPad\")\n",
        "l2 = Laptop(\"MacBook\", \"Air\")\n",
        "\n",
        "# podemos acceder al atributo de clase como propiedad de clase\n",
        "print(Laptop.bateria)\n",
        "\n",
        "# podemos acceder al atributo de clase como propiedad de instancia\n",
        "print(l2.bateria)   # Accedemos al atributo batería del objeto creado\n",
        "\n",
        "# Acceder al diccionario de atributos del objeto\n",
        "print(l1.__dict__)  # Output: {'marca': 'Lenovo', 'modelo': 'ThinkPad'}\n",
        "\n",
        "# Agregar un nuevo atributo al objeto\n",
        "l1.pantalla = \"4K\"\n",
        "print(l1.__dict__)  # Output: {'marca': 'Lenovo', 'modelo': 'ThinkPad', 'pantalla': '4K'}"
      ],
      "metadata": {
        "id": "vz2Jh8fd3qzO",
        "outputId": "9b367e9e-f8ef-402c-c0dc-e5efcdf2e495",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Integrada\n",
            "Integrada\n",
            "{'marca': 'Lenovo', 'modelo': 'ThinkPad'}\n",
            "{'marca': 'Lenovo', 'modelo': 'ThinkPad', 'pantalla': '4K'}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "¿Cómo es posible que al poner `l2.bateria` no de error ya que `bateria` es un atributo de clase y lo estoy aplicando sobre la instancia `l2`?\n",
        "\n",
        "Esto se debe a que se sigue este orden de actuación:\n",
        "1. Se verifica si el atributo existe dentro del objeto, y en ese caso se aplica como atributo de instancia, y si no es así se pasa al paso 2\n",
        "2. Se verifica si el atributo existe dentro de la clase, y en ese caso se aplica como atributo de clase. Esto solo funciona para LECTURA.\n",
        "3. Si no existe ni como atributo de instancia ni como atributo de clase da Error.\n",
        "\n",
        "Al escribir `l2.bateria` Python mira a ver si `bateria`existe como atributo de instancia y como no es así pasa al paso 2 y mira a ver si `bateria`existe como atributo de clase, y como si es así, entonces imprime el valor de `bateria`como atributo de clase, pese a que lo estamos aplicando sobre `l2` que es una instancia."
      ],
      "metadata": {
        "id": "P14v-RyAAEY2"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(id(Laptop.bateria))   # da el ID del atributo de clase bateria\n",
        "print(id(l2.bateria))       # da el mismo ID porque se trata del mismo atributo"
      ],
      "metadata": {
        "id": "zFXdrKxhCDaE",
        "outputId": "94211a3d-b179-4170-b6b9-61bf910c8199",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "140130402966000\n",
            "140130402966000\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(l2.conector)\n",
        "print(id(l2.conector))\n",
        "\n",
        "# queremos cambiar la asignación del atributo\n",
        "l2.conector = \"USB-C\"   # pero en realidad estamos creando uno nuevo\n",
        "                        # el motivo es que el atributo conector es de clase y no de instancia\n",
        "                        # y cuando no existe el atributo de instancia se usa el de clase\n",
        "                        # pero solo para LECTURA\n",
        "l2.autonomia = 300      # Así añadimos un atributo nuevo al objeto de forma dinámica\n",
        "                        # Esto también es lo que se hizo cuando se añadío el conector USB-C\n",
        "                        # era un atributo nuevo, distindo del atributo de clase del mismo nombre\n",
        "\n",
        "print(l2.conector)\n",
        "print(id(l2.conector))  # podemos comprobar que es un nuevo atributo ya que el ID es diferente\n",
        "\n",
        "print(l2.__dict__)      # podemos comprobar que ahora el conector de tipo USB-C es el\n",
        "                        # atributo de la instancia l2 ya que se encuentra el diccionario\n",
        "                        # Output: {'marca': 'MacBook', 'modelo': 'Air', 'conector': 'USB-C'}"
      ],
      "metadata": {
        "id": "gsNpvbBw0K9M",
        "outputId": "b4498f26-2fca-4341-f37c-be5e8a385dc9",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "USB-C\n",
            "140305896094576\n",
            "USB-C\n",
            "140305496240176\n",
            "{'marca': 'MacBook', 'modelo': 'Air', 'conector': 'USB-C'}\n"
          ]
        }
      ]
    }
  ]
}