{
  "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/lists.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eYHfIKROMii0"
      },
      "source": [
        "# Listas\n",
        "\n",
        "Las **listas** son un tipo de objeto que nos permite guardar una secuencia de otros objetos, actualizarlos, añadir nuevos y borrarlos. A diferencia de todos los tipos que hemos visto hasta ahora, las listas con objetos **mutables**, es decir, pueden cambiar durante la ejecución de nuestro programa. \n",
        "\n",
        "Para crear una lista en Python usamos corchetes y escribimos sus elementos separados por comas `[item1, item2, ..., itemN]`. Los objetos de una lista **no tienen por qué ser del mismo tipo de objeto**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JmvoO1AnNirL",
        "outputId": "e5848d0d-6cc9-4569-9237-6be666a8b207"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "[3.5, None, 'foo']"
            ]
          },
          "execution_count": 1,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "[3.5, None, \"foo\"]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KFHrUKuPRn6y",
        "outputId": "711c83e2-1da3-43df-9d7c-09e9c50f79cd"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "list"
            ]
          },
          "execution_count": 2,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "type([1, 2, 3])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rk6GMpGBRpjZ",
        "outputId": "aad0dce6-1fc5-445d-c93f-5bff78705cc0"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "[]"
            ]
          },
          "execution_count": 3,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# lista vacía\n",
        "[]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RNbpSdysRvDl"
      },
      "source": [
        "Puedes incluir variables y expresiones en la definición de la lista. Python evaluará dichas expresiones y luego construirá la lista. "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bfBlnz8nUf1n",
        "outputId": "76a38206-9be7-46c2-d06c-30b62afcc4dc"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "[True, 'Foo', 25, [1, 2]]"
            ]
          },
          "execution_count": 4,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "x = \"foo\"\n",
        "[2 < 3, x.capitalize(), 5**2, [1, 2]]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IX91AgsCUnMT"
      },
      "source": [
        "El tipo `list` puede ser utilizado para convertir otros tipos de objetos a listas, en concreto aquellos que sean **iterables**, cosa que definiremos más adelante. "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TSKnJKX-U4-x",
        "outputId": "a2731d8c-3a23-4d80-e068-e49f3712df91"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']"
            ]
          },
          "execution_count": 5,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "list(\"hello world\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 171
        },
        "id": "7u0UNSmPU62b",
        "outputId": "e634035d-7e5c-4d76-a82e-3d7b1616eacc"
      },
      "outputs": [
        {
          "ename": "TypeError",
          "evalue": "ignored",
          "output_type": "error",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-6-7ade7017386b>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mlist\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m: 'int' object is not iterable"
          ]
        }
      ],
      "source": [
        "list(1)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WHBI-StWU9KR",
        "outputId": "e146fe5c-c56e-40e9-b946-1a3ed9cd61cb"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "[1]"
            ]
          },
          "execution_count": 7,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "list([1])"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "## Las listas son iterables\n",
        "Los **objetos iterables** son aquellos compatibles con operaciones de iteración, la más común de ellas el buque *for*, que veremos más adelante. Otros objetos iterables pueden ser las tuplas, los diccionarios, los conjuntos, los rangos, los generadores, los arrays de numpy etc. Dado un iterable `s`, podemos realizar las siguientes operaciones\n",
        "\n",
        "| Operación | Descripción |\n",
        "|:---------------|:-----------------|\n",
        "| `for vars in s:`| Iteración |\n",
        "| `x, y, ... = s`| Deshacer en variables |\n",
        "| `x in s` `x not in s`| Pertenencia |\n",
        "| `[a, *s, b]`| Expandir |"
      ],
      "metadata": {
        "id": "TNLP8lOB8GS7"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Veamos algunos ejemplos"
      ],
      "metadata": {
        "id": "Hpk-UYZW-ulo"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "items = [3, 4, 5]\n",
        "x, y, z = items\n",
        "print(x, y, z)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1y3BXbb6-oz7",
        "outputId": "24125444-f1c7-4201-d70c-8dc4b5790204"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "3 4 5\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "\"a\" in items"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WrLIKQ7w-ttt",
        "outputId": "d375ed9b-cf5a-42c2-f69f-d8d47dbc7b7a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {},
          "execution_count": 20
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "a = [1, 2, *items, 6]\n",
        "a"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Podyie0C-8U_",
        "outputId": "cd66c739-a85d-42b7-a37e-bb950f91b031"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[1, 2, 3, 4, 5, 6]"
            ]
          },
          "metadata": {},
          "execution_count": 21
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Existen muchas funciones predefinidas que aceptan un iterable como argumento, aquí exponemos algunas de ellas\n",
        "\n",
        "| Función | Descripción |\n",
        "|:---------------|:-----------------|\n",
        "| `list(s)`| Crea una lista a partir de `s`|\n",
        "| `tuple(s)`| Crea una tupla a partir de `s`|\n",
        "| `set(s)`| Crea una conjunto a partir de `s`|\n",
        "| `min(s, [,key])`| Mínimo de `s`|\n",
        "| `max(s, [,key])`| Máximo de `s`|\n",
        "| `any(s)`| Devuelve `True` si algún item de `s` es verdadero|\n",
        "| `all(s)`| Devuelve `True` si todos los items de `s` son verdaderos|\n",
        "| `sum(s, [, initial])`| Suma de `s` |\n",
        "| `sorted(s, [, key])`| Crea una lista ordenada |\n"
      ],
      "metadata": {
        "id": "gOHvUH04_VM5"
      }
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cehmTnGFVBzV"
      },
      "source": [
        "---\n",
        "## Las listas son secuencias\n",
        "\n",
        "Al igual que las cadenas, las listas **son secuencias**, por lo que el orden de sus objetos es importante y podemos acceder a los mismo mediante un índice entero que empieza en cero. "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "D5lEyj4mWb-E",
        "outputId": "773793a3-191a-47f5-bf22-e981f457654e"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "execution_count": 8,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# El orden importa\n",
        "[1, \"a\", True] == [\"a\", 1, True]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "a76IipNqWhiX"
      },
      "source": [
        "Podemos utilizar la misma sintaxis de indexado que vimos con las cadenas utilizando corchetes y `:`. \n",
        "\n",
        "En las secuencias, el método que nos da la longitud del objeto es `len`"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hqpUgwgjW-GD",
        "outputId": "e75a98c5-35c7-4374-835c-f6de1db1d0a8"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "5"
            ]
          },
          "execution_count": 9,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "x = [2, 4, 6, 8, 10]\n",
        "len(x)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "D0oJAeMbXDM1",
        "outputId": "8624c088-2552-41c0-d88e-fb5a0d837aec"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "11"
            ]
          },
          "execution_count": 10,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "x = \"hello world\"\n",
        "len(x)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 190
        },
        "id": "y4eiEu3CXR6O",
        "outputId": "46777d4a-1289-4a89-9c83-90ae4fb4dd52"
      },
      "outputs": [
        {
          "ename": "TypeError",
          "evalue": "ignored",
          "output_type": "error",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-11-d7736ab3e6ed>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m: object of type 'int' has no len()"
          ]
        }
      ],
      "source": [
        "x = 1\n",
        "len(x)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ikcTeUSuX4Zo"
      },
      "source": [
        "---\n",
        "## Las listas son mutables\n",
        "\n",
        "Las listas son utilizadas cuando queramos almacenar datos que pueden cambiar o deben actualizarse, ya que *las listas pueden cambiar una vez han sido creadas*, o dicho de otro modo, son objetos **mutables**. Veámoslo con un ejemplo"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dyrlruFjYccj",
        "outputId": "ef75fa33-7203-45b3-bcb3-40d9b138917c"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "[2, 'apple', 6, 8, 10]"
            ]
          },
          "execution_count": 16,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "x = [2, 4, 6, 8, 10]\n",
        "y = [2, 4, 6, 8, 10]\n",
        "\n",
        "# asignamos una cadena al segundo objeto de x\n",
        "x[1] = \"apple\"\n",
        "x"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cSm9JjtYYgCc",
        "outputId": "23a66362-c7aa-4378-fbee-a2b05a3dce75"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "[2, -3, -4, -5, 10]"
            ]
          },
          "execution_count": 20,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# podemos realizar asignaciones a nivel de lista\n",
        "y[1:4] = [-3, -4, -5]\n",
        "y"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jKq9JKUKZQs8"
      },
      "source": [
        "Dos métodos muy utilizados a la hora de manipular listas son el `append` que nos permiten añadir un elemento a la cola de lista y `extend` para añadir varios"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bDCFze6jZknl",
        "outputId": "3bc730d1-7555-4dee-ad8e-954184b3147b"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "[2, 4, 6, 8, 10, 'foo']"
            ]
          },
          "execution_count": 23,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "x = [2, 4, 6, 8, 10]\n",
        "x.append(\"foo\")\n",
        "x"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "uXJBMLRRZof6",
        "outputId": "cbcb38f7-ea46-46b4-ac4b-d145bcefb193"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "[2, 4, 6, 8, 10, 'foo', True, False, None]"
            ]
          },
          "execution_count": 24,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# a extend tenemos que pasarle una lista de objetos\n",
        "x.extend([True, False, None])\n",
        "x"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LK7dInqoZyBW"
      },
      "source": [
        "Estos métodos realizan las operaciones *inplace*, es decir, modifican el objeto sin necesidad de tener que asignarlo. No tiene sentido escribir algo como `x = x.append(\"foo\")`, de hecho el método `append` devuelve `None`"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oHmGveVgaRri"
      },
      "source": [
        "Otros métodos que pueden ser útiles con listas son \n",
        "- `pop(n)`: devuelve el elemento `n`-ésimo y lo borra de la lista. Devuelve un `IndexError` si `n` está fuera del índice.\n",
        "- `remove(a)`: borra el primer elemento cuyo valor coincida con `a`. Devuelve un `ValueError` si no encuentra el valor. \n",
        "- `insert(n, a)`: inserta el objeto `a` en la posición `n`-ésima de la lista"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 36
        },
        "id": "BguQEa5vazye",
        "outputId": "c321678d-02ac-4788-ae2e-3526392ed9ca"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'c'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 1
        }
      ],
      "source": [
        "x = [\"a\", \"b\", \"c\", \"d\"]\n",
        "x.pop(2)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Ascz_a90a59v",
        "outputId": "d721f4c9-dd2b-49bd-93c9-5eb44e0333a0"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['a', 'b', 'd']"
            ]
          },
          "metadata": {},
          "execution_count": 2
        }
      ],
      "source": [
        "x"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GDWYMJpvbAMj",
        "outputId": "6c944a59-bbd7-4f66-d50c-b1c85724958b"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['a', 'b', 'd', 'a']"
            ]
          },
          "metadata": {},
          "execution_count": 3
        }
      ],
      "source": [
        "x.append(\"a\")\n",
        "x"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "LhAJavfLbfpJ"
      },
      "outputs": [],
      "source": [
        "x.remove(\"a\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wVNeMbz0bjAX",
        "outputId": "8a769adf-6ea5-4901-84f2-26509df29ce2"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['b', 'd', 'a']"
            ]
          },
          "metadata": {},
          "execution_count": 5
        }
      ],
      "source": [
        "x"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "x.insert(2, None)\n",
        "x"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TkCOd1TR5dmk",
        "outputId": "18900d8e-9958-42e2-fef7-4ab0ab5768f8"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['b', 'd', None, 'a']"
            ]
          },
          "metadata": {},
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Podemos concatenar listas usando el operador `+`. En caso de tener listas anidadas, es posible aplicar directamente más de una operación de indexado. "
      ],
      "metadata": {
        "id": "2O5VVVwT504i"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "x = [[1, \"foo\"], [\"bar\", None], True, 3.5]\n",
        "x[1][0]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 36
        },
        "id": "FNLsnPk66Kmt",
        "outputId": "154d7743-84b5-432c-b3e1-fd063ae90aee"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'bar'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Tb2z78UQynEt"
      },
      "source": [
        ":::{exercise}\n",
        ":label: lists-index\n",
        "\n",
        "Modifica la siguiente lista\n",
        "\n",
        "```\n",
        "l = [[1, \"foo\"], [\"bar\", None], True, 3.5]\n",
        "```\n",
        "para obtener \n",
        "\n",
        "```\n",
        "[[1, \"baz\"], [\"bar\", None], True, -1.5, [0, 1, 0]]\n",
        "```\n",
        "\n",
        ":::"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        ":::{exercise}\n",
        ":label: lists-comparison\n",
        "\n",
        "Condiera una lista `s` y definamos \n",
        "\n",
        "```\n",
        "r = list(s)\n",
        "t = s\n",
        "```\n",
        "\n",
        "Indica si las siguientes expresiones son verdaderas o falsas \n",
        "- `r == s`\n",
        "- `r is s`\n",
        "- `s is t`\n",
        "\n",
        ":::"
      ],
      "metadata": {
        "id": "t-OHv0q3In29"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Para el siguiente ejercicio, puedes utilizar el módulo `time` o el [**comando mágico**](https://ipython.readthedocs.io/en/stable/interactive/magics.html) de jupyter `%%time` para obtener el tiempo de ejecución de una celdilla. "
      ],
      "metadata": {
        "id": "g6oJoG2vRYeG"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "%%time\n",
        "\n",
        "3**999"
      ],
      "metadata": {
        "id": "ILIzM16jR7XG",
        "outputId": "40a770bc-ff15-48b1-d1d3-0a7f55c593e5",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "CPU times: user 9 µs, sys: 0 ns, total: 9 µs\n",
            "Wall time: 13.4 µs\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "440690273160268878963485086584048121988474010917382722554973456075609532448901633180259437950202687321303259232290860785316984860700206303955114241752651224675873408399440267959338258076321613758130133372529539347042982605207698146020522057684695558163502059375160114801849018132346298605821789418305378740276756187926194096742805466102629298972852134694966312536457747390615453312898505588339646862703020142029890479621367604783461882915721944003538122044057700922967618406667"
            ]
          },
          "metadata": {},
          "execution_count": 65
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import time\n",
        "\n",
        "start = time.time()\n",
        "3**999\n",
        "end = time.time()\n",
        "print(f\"Execution time: {end - start:0.8f} seconds\")"
      ],
      "metadata": {
        "id": "NpzhtYgETGj2",
        "outputId": "b3ab9a5f-9e1f-402d-9ab6-abbb6608d182",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Execution time: 0.00009036 seconds\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        ":::{exercise}\n",
        ":label: lists-membership\n",
        "\n",
        "Usando la estructura `list(range(n))`, crea listas de diferentes tamaños y estima la complejidad computacional en cuanto a tiempo de cómputo de comprobar la pertenencia a una lista. \n",
        "\n",
        ":::"
      ],
      "metadata": {
        "id": "fvQyxNzbIlC2"
      }
    }
  ],
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyNx96k6EABw5szvuaOUIKqM",
      "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
}