{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/javlintor/curso-python-us/blob/main/notebooks/introduction-python/numeric-types.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BgCkdkS4oIIo"
      },
      "source": [
        "# Tipos numéricos\n",
        "\n",
        "El conjunto de operaciones entre tipos numéricos se resumen en la siguiente tabla \n",
        "\n",
        "| Operation |                       Description                       |\n",
        "|:---------:|:-------------------------------------------------------:|\n",
        "| `x + y  `   | Suma de dos números                                     |\n",
        "| `x - y  `   | Reta de dos números                              |\n",
        "| `x * y  `   | Producto de dos números                                 |\n",
        "| `x / y  `   | Cociente de dividir dos números                                |\n",
        "| `x // y `   | Cociente entero de dividir dos números        |\n",
        "| `x % y  `   | Resto de dividir `x` entre `y` |\n",
        "| `x ** y `   | `x` elevado a `y`                                 |\n",
        "| `-x     `   | Cambiar el signo de `x`                                        |\n",
        "| `abs(x)   ` | Valor absoluto                          |\n",
        "| `x == y `   | Comprobar si dos números tienen el mismo valor                |\n",
        "| `x != y `   | Negación de `==`              |\n",
        "| `x > y  `   | Verifica si `x` es estrictamente mayor que `y`                            |\n",
        "| `x >= y `   | Verifica si `x` es mayor o igual que `y`                |\n",
        "| `x < y  `   | Verifica si `x` es estrictamente menos que `y`                               |\n",
        "| `x <= y `   | Verifica si `x` es menor o igual que `y`                 |"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GLlo1Hobtvfq"
      },
      "source": [
        "---\n",
        "## Enteros\n",
        "\n",
        "Como hemos visto ya, los **enteros** en Python son utilizados para representar el conjunto de números enteros $\\mathbb{Z} = \\{\\dots, -2, -1, 0, 1, 2, \\dots \\}$ mediante el tipo predefinido `int`. \n",
        "\n",
        "Puedes crear enteros arbitrariamente grandes, Python reservará tanta memoria como sea necesario (hasta quedarnos sin memoria) para almacenarlo."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4fe6BWeQOFDs"
      },
      "source": [
        "La conversión de `float` a `int` se realiza truncando los decimales mediante la función `math.floor`."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pcwWRoiHODWt",
        "outputId": "51aaa7a1-f915-41cc-a70b-d9716b7752cd"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "1\n"
          ]
        }
      ],
      "source": [
        "a = 1.3\n",
        "print(int(a))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gEofIF3hORML",
        "outputId": "04f26705-2aac-4cf2-be22-fb58bb8d4f77"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "1\n"
          ]
        }
      ],
      "source": [
        "b = 1.7\n",
        "print(int(b))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "p3-MwLfit8y4"
      },
      "source": [
        "---\n",
        "## Flotantes"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ibygc4oOPn3E"
      },
      "source": [
        "Los **flotantes** se utilizan para representar números reales con un número determinado de cifras decimales. El tipo para representar estos objetos es `float`"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pA9axY_sP7uP",
        "outputId": "1fbb1b70-bed3-464b-ceae-e34f577ea41d"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "execution_count": 3,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "isinstance(1, float)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "i8HUzFoDQE8U",
        "outputId": "5aa22fb5-06ee-42d1-d48e-6d5c33ec3de6"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "execution_count": 4,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "isinstance(1., float)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rNmwqoiwQEtv",
        "outputId": "4d0dfe8a-d621-4e19-d22b-16309e1f884b"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "float"
            ]
          },
          "execution_count": 5,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "type(10 / 5)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3--mQDNOQENM",
        "outputId": "6ea49357-b49e-42a5-820b-66135ad45a76"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "0.43784"
            ]
          },
          "execution_count": 6,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "float(\"0.43784\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kY4jz0FCQP4C",
        "outputId": "8e86fb2e-30e6-4fff-9e44-8215224186b4"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "-3.0"
            ]
          },
          "execution_count": 7,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "float(-3)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-tk7v61WQW3W"
      },
      "source": [
        "Los flotantes también se pueden definir utilizando **notación científica**, que se implementa mediente el carácter `e` para simbolizar $\\times 10$. Por ejemplo\n",
        "- $2.5 \\times 10^3 →$ `2.5e3` \n",
        "- $1.34 \\times 10^{-7} →$ `1.34e-7` "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "EEfEg5elRE5G",
        "outputId": "48ca889d-4ac2-4566-8bc4-b9ccc46f7dae"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "2500.0\n",
            "1.34e-07\n"
          ]
        }
      ],
      "source": [
        "a = 2.5e3\n",
        "b = 1.34e-7\n",
        "print(a)\n",
        "print(b)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8-hn0vWaRH3U"
      },
      "source": [
        "En este último ejemplo, vemos que a la hora de llamar a la función `print`, Python decide si mostrar el número en notación científica o escribir todas las cifras. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "i2Xj23COUbw4"
      },
      "source": [
        "Aunque los enteros de Python pueden tener una longitud tan grande como queramos, los flotantes *tienen una cantida limitada de decimales que pueden almacenar*, en concreto Python dispone de 64 bits de memoria en la mayoría de los casos para guardar el número. Esto se traduce en que usualmente tendremos una capacidad máxima de almacenar **16 decimales** cuando el número se escribe en notación científica. \n",
        "\n",
        "En el siguiente ejemplo vemos que al convertir un entero de 100 dígitos a flotante sólo podemos retener 16. "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "XHZdt6DMWQn4"
      },
      "outputs": [],
      "source": [
        "# Creamos una cadena de longitud 100 llena de 1s\n",
        "digit_str = \"1\"*100 \n",
        "# Convertirmos a entero\n",
        "digit_int = int(\"1\"*100)\n",
        "# Convertimos a float\n",
        "digit_float = float(digit_int)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cMsii3KEWrfJ",
        "outputId": "cafc3883-840b-4358-de27-e6ce40f3fe9b"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"
            ]
          },
          "execution_count": 10,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "digit_int"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9m9DYpvAWtFa",
        "outputId": "a82a42c4-5dbb-4a6a-c3dd-0ae922b87bf7"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "1.111111111111111e+99"
            ]
          },
          "execution_count": 11,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "digit_float"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IQp-z_pUYFDs"
      },
      "source": [
        "Modificar un flotante más allá de su precisión no causará ningún efecto"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "naxeMBSjYNDO",
        "outputId": "75fcf589-1223-4663-f4f1-a24454440449"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "execution_count": 12,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "digit_float == digit_float + 1"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kd7JoZ8DaK4b"
      },
      "source": [
        "Muchas veces el hecho de tener una precesición numérica finita puede llevar a comportamientos inesperados"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "sBUHLpzbaXaH",
        "outputId": "8ee9b4c8-9182-42b5-8854-65dd1ae7733a"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "execution_count": 13,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "0.1 + 0.1 + 0.1 - 0.3 == 0"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "t1JSzU-AaZ1Y",
        "outputId": "71139c48-637f-4fd0-95aa-d6f6a6e3a91e"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "5.551115123125783e-17\n"
          ]
        }
      ],
      "source": [
        "a = 0.1 + 0.1 + 0.1 - 0.3\n",
        "print(a)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WhGVXtzTai2f"
      },
      "source": [
        "> Nunca se debería comprobar directamente si un flotante es igual a otro, en su lugar debería de comprobarse si dos flotantes están arbitrariamente cerca"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ghfq_TrIavsM"
      },
      "source": [
        "Para ello contamos con la función `isclose` del módulo `math`. "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gHdtEHP3bwWl",
        "outputId": "15f18659-1b5e-4d5a-e218-a00f199f3cf0"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "execution_count": 15,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "import math\n",
        "math.isclose(a, 0, abs_tol=1e-5)"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "## Operadores de asignación aumentada \n",
        "\n",
        "En Python disponemos de un ajato muy útil a la hora de actualizar una variable vía una operación aritmética. Por ejemplo, si tenemos una variable `x` y queremos aumentar su valor en `1`, en lugar de escribir "
      ],
      "metadata": {
        "id": "DIxUZdUPyXFf"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "x = 1\n",
        "x = x + 1\n",
        "print(x)"
      ],
      "metadata": {
        "id": "igohC_ywyziC",
        "outputId": "fbcf5bd9-b0ba-4ddf-a554-3599e3e03563",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Podemos utilzar el **operador de asignación aumentada** asociado a `+` "
      ],
      "metadata": {
        "id": "E763ZTIGy2i7"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "x = 1\n",
        "x += 1\n",
        "print(x)"
      ],
      "metadata": {
        "id": "1oRqVUy8y-Gl",
        "outputId": "33cbf13c-c5e2-4361-89a9-afbf9891bb66",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Otros ejemplos pueden ser los operadores `*=`, `-=`, `/=`, `**=`, `%=` etc. En general, lo que estamos haciendo es calcular un nuevo valor de nuestra variable y posteriormente asignándolo a la misma. Esta técnica también se puede utilizar con tipo que no sean numéricos, por ejemplo con una cadena "
      ],
      "metadata": {
        "id": "v6lw4UAhzDuM"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "a = \"foo\"\n",
        "a += \"bar\"\n",
        "print(a)"
      ],
      "metadata": {
        "id": "hb1kJFoazh7I",
        "outputId": "6e56eb1d-c1ff-4d48-820f-910ed89a0a70",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "foobar\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "## Otros tipos numéricos \n",
        "\n",
        "Existen módulos en la librería estándar que extienden los tipos predefinidos, como pueden ser el módulo [fractions](https://docs.python.org/3/library/fractions.html#module-fractions) para trabajar con representaciones exactas de los números racionales o [decimal](https://docs.python.org/3/library/decimal.html) para controlar la precisión de los decimales."
      ],
      "metadata": {
        "id": "DwTeXBDLL_jK"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        ":::{exercise}\n",
        ":label: numeric-types-exp-abs\n",
        "\n",
        "Usando funciones del módulo `math`, calcula el valor de la función $f(x) = e^{|x - 2|}$ en $x = -0.2$\n",
        "\n",
        ":::"
      ],
      "metadata": {
        "id": "VxaKy9n7NJG-"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        ":::{exercise}\n",
        ":label: numeric-types-cientific-notation\n",
        "\n",
        "Haz uso de la notación científica para calcular el orden de magnitud del inverso del cuadrado de la longitud de Planck.\n",
        "\n",
        ":::"
      ],
      "metadata": {
        "id": "7nwX1SQvNm5x"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        ":::{exercise}\n",
        ":label: numeric-types-decimals\n",
        "\n",
        "Con ayuda del módulo `decimals` calcula el décimal número 100 del número $\\frac{77}{314}$.\n",
        "\n",
        ":::"
      ],
      "metadata": {
        "id": "hbwPMtBw3mOc"
      }
    }
  ],
  "metadata": {
    "colab": {
      "provenance": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3.9.1 64-bit",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "name": "python",
      "version": "3.9.1"
    },
    "vscode": {
      "interpreter": {
        "hash": "397704579725e15f5c7cb49fe5f0341eb7531c82d19f2c29d197e8b64ab5776b"
      }
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}