Python_CoderDojo09.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Python_CoderDojo09.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "authorship_tag": "ABX9TyPprikc5p9WRvAgqqFgAhAl",
      "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/seldoncode/Python_CoderDojo/blob/main/Python_CoderDojo09.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iyonWVXvnw_R"
      },
      "source": [
        "# Módulos\n",
        "Con ```import``` conseguimos importar librerías que contienen una serie de funciones programadas que nos pueden resultar útiles.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "z0m9RdCEI6bP"
      },
      "source": [
        "## Módulo ```math```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GTaIUczanrRr",
        "outputId": "5ed1addc-aca3-454d-e434-4430ccf459f5"
      },
      "source": [
        "import math\n",
        "dir(math)     # proporciona el listado de todas las funciones de la librería"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['__doc__',\n",
              " '__loader__',\n",
              " '__name__',\n",
              " '__package__',\n",
              " '__spec__',\n",
              " 'acos',\n",
              " 'acosh',\n",
              " 'asin',\n",
              " 'asinh',\n",
              " 'atan',\n",
              " 'atan2',\n",
              " 'atanh',\n",
              " 'ceil',\n",
              " 'copysign',\n",
              " 'cos',\n",
              " 'cosh',\n",
              " 'degrees',\n",
              " 'e',\n",
              " 'erf',\n",
              " 'erfc',\n",
              " 'exp',\n",
              " 'expm1',\n",
              " 'fabs',\n",
              " 'factorial',\n",
              " 'floor',\n",
              " 'fmod',\n",
              " 'frexp',\n",
              " 'fsum',\n",
              " 'gamma',\n",
              " 'gcd',\n",
              " 'hypot',\n",
              " 'inf',\n",
              " 'isclose',\n",
              " 'isfinite',\n",
              " 'isinf',\n",
              " 'isnan',\n",
              " 'ldexp',\n",
              " 'lgamma',\n",
              " 'log',\n",
              " 'log10',\n",
              " 'log1p',\n",
              " 'log2',\n",
              " 'modf',\n",
              " 'nan',\n",
              " 'pi',\n",
              " 'pow',\n",
              " 'radians',\n",
              " 'remainder',\n",
              " 'sin',\n",
              " 'sinh',\n",
              " 'sqrt',\n",
              " 'tan',\n",
              " 'tanh',\n",
              " 'tau',\n",
              " 'trunc']"
            ]
          },
          "metadata": {},
          "execution_count": 1
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Ae18La-KqL2-",
        "outputId": "267b2c74-6d3f-4b94-af0c-48f1de982087"
      },
      "source": [
        "math.sqrt(9)         # raiz cuadrada"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3.0"
            ]
          },
          "metadata": {},
          "execution_count": 2
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dD5SZwpQqhsg"
      },
      "source": [
        "## Calcular el perímetro de la circunferencia"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9hQynDz0qrpL",
        "outputId": "70124e4d-c544-411c-ce7e-15aec7bdc84a"
      },
      "source": [
        "import math\n",
        "r = 10     # radio\n",
        "perimetro = 2*math.pi*r   # perimetro=2*pi*r\n",
        "perimetro"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "62.83185307179586"
            ]
          },
          "metadata": {},
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RoYyU8O7sQKO"
      },
      "source": [
        "### Calcula el área del círculo"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ckfKqgWOtCL9"
      },
      "source": [
        "#### Solución 1"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WK8RpYZGsWYd",
        "outputId": "58f3977e-2a0f-419c-c84c-a597debf6a68"
      },
      "source": [
        "import math\n",
        "r = 10      # radio\n",
        "area = math.pi*r**2          # area=pi*r^2\n",
        "area"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "314.1592653589793"
            ]
          },
          "metadata": {},
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "llVJv5vltGjY"
      },
      "source": [
        "#### Solución 2"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "eDhKlDXqtKRA",
        "outputId": "a3ab620c-aa9f-477d-a640-4b4f89071cdf"
      },
      "source": [
        "from math import pi\n",
        "r = 10      # radio\n",
        "area = pi*r**2\n",
        "area"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "314.1592653589793"
            ]
          },
          "metadata": {},
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NIbVAshRtd8-"
      },
      "source": [
        "#### Solución 3"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-e_IjG9rtgja",
        "outputId": "9cc5caa9-8d1a-498a-9e77-ad366240f3dd"
      },
      "source": [
        "from math import pi, pow\n",
        "r = 10      # radio\n",
        "area = pi*pow(r,2)         # pow eleva a una potencia\n",
        "area"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "314.1592653589793"
            ]
          },
          "metadata": {},
          "execution_count": 2
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1pcsbxqwtt9O"
      },
      "source": [
        "#### Solución 4"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jNhCzFFatxEI",
        "outputId": "33d49533-cade-496f-d3ed-04a8f7ba8ef5"
      },
      "source": [
        "from math import *         # importa todas las funciones de la librería\n",
        "r = 10      # radio\n",
        "area = pi*pow(r,2)         # pow eleva a una potencia\n",
        "area"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "314.1592653589793"
            ]
          },
          "metadata": {},
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Kn5RzLe7u-be"
      },
      "source": [
        "### Teorema de Pitágoras\n",
        "La hipotenusa es igual a la raiz cuadrada de la suma del cuadrado de los catetos.\n",
        "\n",
        "h = raiz(catero1\\**2 + cateto2**2)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GnllrwBUvZaf",
        "outputId": "c0714ff1-7575-44be-9b15-8f6dc90675ed"
      },
      "source": [
        "import math\n",
        "a = 3                           # cateto 1\n",
        "b = 4                           # cateto 2\n",
        "c = math.sqrt(a**2+b**2)        # hipotenusa\n",
        "c"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "5.0"
            ]
          },
          "metadata": {},
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QEBAOFwPy3hJ"
      },
      "source": [
        "# Módulo ```random```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bJ5ZUDZ7y95s",
        "outputId": "e21b8153-d7a4-4e5a-fe8a-1173333e99fb"
      },
      "source": [
        "import random\n",
        "dir(random)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['BPF',\n",
              " 'LOG4',\n",
              " 'NV_MAGICCONST',\n",
              " 'RECIP_BPF',\n",
              " 'Random',\n",
              " 'SG_MAGICCONST',\n",
              " 'SystemRandom',\n",
              " 'TWOPI',\n",
              " '_BuiltinMethodType',\n",
              " '_MethodType',\n",
              " '_Sequence',\n",
              " '_Set',\n",
              " '__all__',\n",
              " '__builtins__',\n",
              " '__cached__',\n",
              " '__doc__',\n",
              " '__file__',\n",
              " '__loader__',\n",
              " '__name__',\n",
              " '__package__',\n",
              " '__spec__',\n",
              " '_acos',\n",
              " '_bisect',\n",
              " '_ceil',\n",
              " '_cos',\n",
              " '_e',\n",
              " '_exp',\n",
              " '_inst',\n",
              " '_itertools',\n",
              " '_log',\n",
              " '_os',\n",
              " '_pi',\n",
              " '_random',\n",
              " '_sha512',\n",
              " '_sin',\n",
              " '_sqrt',\n",
              " '_test',\n",
              " '_test_generator',\n",
              " '_urandom',\n",
              " '_warn',\n",
              " 'betavariate',\n",
              " 'choice',\n",
              " 'choices',\n",
              " 'expovariate',\n",
              " 'gammavariate',\n",
              " 'gauss',\n",
              " 'getrandbits',\n",
              " 'getstate',\n",
              " 'lognormvariate',\n",
              " 'normalvariate',\n",
              " 'paretovariate',\n",
              " 'randint',\n",
              " 'random',\n",
              " 'randrange',\n",
              " 'sample',\n",
              " 'seed',\n",
              " 'setstate',\n",
              " 'shuffle',\n",
              " 'triangular',\n",
              " 'uniform',\n",
              " 'vonmisesvariate',\n",
              " 'weibullvariate']"
            ]
          },
          "metadata": {},
          "execution_count": 1
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "A0BQWiSFnLGW"
      },
      "source": [
        "## Numero aleatorio entero entre dos extremos"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7H-rU8130HVc",
        "outputId": "3b4fa4bb-a8b9-4d35-9fb6-fd53da6db390"
      },
      "source": [
        "random.randint(10,20)   # número aleatorio entero entre 10 y 20 ambos incluidos"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "10"
            ]
          },
          "metadata": {},
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "z8C6oCEanV3s"
      },
      "source": [
        "### Crear una lista de números aleatorios\n",
        "* La lista contiene 19 números aleatorios entre 10 y 20, ambos incluidos.\n",
        "* La lista contiene valores repetidos.\n",
        "* Mostrar la lista ordenada."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "66c7ZbPWzHLR",
        "outputId": "b53b12c1-da60-4753-e9e7-1e1a0d2526a7"
      },
      "source": [
        "import random\n",
        "random.seed()                        # la semilla, permite dar más aleatoriedad\n",
        "lista = []\n",
        "for _ in range(19):\n",
        "  lista.append(random.randint(10,20))\n",
        "\n",
        "lista.sort()\n",
        "lista"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[10, 13, 13, 13, 14, 15, 15, 15, 15, 16, 16, 16, 16, 17, 17, 19, 19, 20, 20]"
            ]
          },
          "metadata": {},
          "execution_count": 11
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "druzXhZO0F-A"
      },
      "source": [
        "### Adivina el número en siete intentos\n",
        "* Generar un número secreto entre 1 y 100, ambos incluidos.\n",
        "* Se dispone de 7 intentos para adivinar el número secreto.\n",
        "* Por cada número se indica si el número secreto es mayor o menos.\n",
        "* Si se adivina el número, decir en que tirada se ha conseguido."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qiPZ6o3-0zMW",
        "outputId": "6d4cc3a3-0064-4f99-f043-79eef664ba44"
      },
      "source": [
        "import random\n",
        "secreto = random.randint(1,100)\n",
        "for tirada in range(7):\n",
        "  n = int(input(f\"{tirada+1}. Introduzca un número: \"))\n",
        "  if n==secreto:\n",
        "    print(\"Felicidades, lo adivinó.\")\n",
        "    print(f\"Lo ha conseguido en la tirada {tirada+1}.\")\n",
        "    break\n",
        "  elif secreto>n:\n",
        "    print(\"El número secreto es mayor.\")\n",
        "  else:\n",
        "    print(\"El número secreto es menor.\")\n",
        "\n",
        "print(f\"El número secreto era {secreto}.\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1. Introduzca un número: 50\n",
            "El número secreto es menor.\n",
            "2. Introduzca un número: 25\n",
            "El número secreto es menor.\n",
            "3. Introduzca un número: 12\n",
            "El número secreto es menor.\n",
            "4. Introduzca un número: 6\n",
            "El número secreto es menor.\n",
            "5. Introduzca un número: 3\n",
            "El número secreto es mayor.\n",
            "6. Introduzca un número: 4\n",
            "El número secreto es mayor.\n",
            "7. Introduzca un número: 5\n",
            "Felicidades, lo adivinó.\n",
            "Lo ha conseguido en la tirada 7.\n",
            "El número secreto era 5.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1cB7z6_p3Qcn"
      },
      "source": [
        "### Elegir aleatoriamente de una secuencia: ```choice```\n",
        "Podemos elegir de una:\n",
        "* lista\n",
        "* tupla\n",
        "* rango (range)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "INfbsgx53bhq",
        "outputId": "87797d68-e0fd-4c9a-d30b-9419be24fdca"
      },
      "source": [
        "random.choice([1,2,3])                               # elegir de una lista"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3"
            ]
          },
          "metadata": {},
          "execution_count": 18
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "Jk9mAE_T3kGb",
        "outputId": "502ba2cb-5b01-42e8-def1-25df103e19bb"
      },
      "source": [
        "random.choice((\"Madrid\",\"París\",\"Londres\",\"Roma\"))   # elegir de una tupla"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'Londres'"
            ]
          },
          "metadata": {},
          "execution_count": 19
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LpeV5i7b3yNH",
        "outputId": "aa3ea5bb-fbfe-4330-a61c-d3a5337a1e18"
      },
      "source": [
        "random.choice(range(1,100))                           # elegir de un range"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "39"
            ]
          },
          "metadata": {},
          "execution_count": 20
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Q7oZSfSu4_90"
      },
      "source": [
        "### Lanzar al aire una moneda 100 veces\n",
        "Lanzar al aire una moneda 100 veces y decir cuantas veces ha salido cara y cuantas veces ha salido cruz."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Kp2s7wQr5INk",
        "outputId": "abdec03c-772b-45a1-b942-aa017131e791"
      },
      "source": [
        "import random\n",
        "caras = 0                            # contador de caras, se inicializa en cero\n",
        "for _ in range(100):\n",
        "  caras += random.randint(0,1)       # suponemos que si sale 1 es cara y si sale 0 es cruz\n",
        "\n",
        "print(f\"Han salido {caras} caras y {100-caras} cruces.\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Han salido 45 caras y 55 cruces.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kc1Nwiskn2zw"
      },
      "source": [
        "## Juego: Piedra, papel, tijera"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JSss9Pl3GZbL"
      },
      "source": [
        "### Solución 1"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hVWXocVYoIrb",
        "outputId": "23021ed3-087a-4e3a-841e-c2acacf5a22c"
      },
      "source": [
        "import random\n",
        "opciones = [\"Piedra\",\"Papel\",\"Tijera\"]\n",
        "jugando = True\n",
        "while jugando:\n",
        "  jugadorA = random.choice(opciones)\n",
        "  jugadorB = random.choice(opciones)\n",
        "  print(f\"El jugador A saca {jugadorA}\")\n",
        "  print(f\"El jugador B saca {jugadorB}\")\n",
        "  jugando = False\n",
        "  if jugadorA==jugadorB:\n",
        "    print(\"Empate\")\n",
        "    jugando = True\n",
        "  elif jugadorA == \"Piedra\" and jugadorB==\"Papel\":\n",
        "    print(\"Gana el jugador B\")\n",
        "  elif jugadorA == \"Piedra\" and jugadorB==\"Tijera\":\n",
        "    print(\"Gana el jugador A\")\n",
        "  elif jugadorA == \"Papel\" and jugadorB==\"Piedra\":\n",
        "    print(\"Gana el jugador A\")\n",
        "  elif jugadorA == \"Papel\" and jugadorB==\"Tijera\":\n",
        "    print(\"Gana el jugador B\")\n",
        "  elif jugadorA == \"Tijera\" and jugadorB==\"Piedra\":\n",
        "    print(\"Gana el jugador B\")\n",
        "  elif jugadorA == \"Tijera\" and jugadorB==\"Papel\":\n",
        "    print(\"Gana el jugador A\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "El jugador A saca Tijera\n",
            "El jugador B saca Tijera\n",
            "Empate\n",
            "El jugador A saca Tijera\n",
            "El jugador B saca Tijera\n",
            "Empate\n",
            "El jugador A saca Papel\n",
            "El jugador B saca Papel\n",
            "Empate\n",
            "El jugador A saca Piedra\n",
            "El jugador B saca Piedra\n",
            "Empate\n",
            "El jugador A saca Papel\n",
            "El jugador B saca Piedra\n",
            "Gana el jugador A\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZQCRoG-tGe5t"
      },
      "source": [
        "### Solución 2\n",
        "Versión simplificada."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rk-E_ximGmKO",
        "outputId": "8f2e4cf0-7c31-446c-a8c3-d8b7a6ecde9e"
      },
      "source": [
        "import random\n",
        "opciones = [\"Piedra\",\"Papel\",\"Tijera\"]\n",
        "jugando = True\n",
        "while jugando:\n",
        "  jugadorA = random.choice(opciones)\n",
        "  jugadorB = random.choice(opciones)\n",
        "  print(f\"El jugador A saca {jugadorA}\")\n",
        "  print(f\"El jugador B saca {jugadorB}\")\n",
        "  jugando = False\n",
        "  if jugadorA==jugadorB:\n",
        "    print(\"Empate\")\n",
        "    jugando = True\n",
        "  elif jugadorA == \"Piedra\" and jugadorB==\"Tijera\":\n",
        "    print(\"Gana el jugador A\")\n",
        "  elif jugadorA == \"Papel\" and jugadorB==\"Piedra\":\n",
        "    print(\"Gana el jugador A\")\n",
        "  elif jugadorA == \"Tijera\" and jugadorB==\"Papel\":\n",
        "    print(\"Gana el jugador A\")\n",
        "  else:\n",
        "    print(\"Gana el jugador B\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "El jugador A saca Tijera\n",
            "El jugador B saca Tijera\n",
            "Empate\n",
            "El jugador A saca Piedra\n",
            "El jugador B saca Piedra\n",
            "Empate\n",
            "El jugador A saca Piedra\n",
            "El jugador B saca Tijera\n",
            "Gana el jugador A\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RuUD15BMHwij"
      },
      "source": [
        "### Reto 9.1. Piedra, papel, tijeras a diez puntos\n",
        "* Programar un juego de \"Piedra, papel, tijeras\" a 10 puntos.\n",
        "* Los jugadores A y B eligen y cada vez que uno gana se anota un punto.\n",
        "* Si hay empate nadie anota.\n",
        "* El primero que llegue a 10 puntos gana.\n",
        "* Mostrar por pantalla todas las tiradas y los puntos que van ganando."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aq02HxXaIyIp"
      },
      "source": [
        "# Módulo ```time```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fyvJXs-MI50F",
        "outputId": "271624a1-b494-4956-d7f6-7109daa2a405"
      },
      "source": [
        "import time\n",
        "dir(time)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['CLOCK_BOOTTIME',\n",
              " 'CLOCK_MONOTONIC',\n",
              " 'CLOCK_MONOTONIC_RAW',\n",
              " 'CLOCK_PROCESS_CPUTIME_ID',\n",
              " 'CLOCK_REALTIME',\n",
              " 'CLOCK_THREAD_CPUTIME_ID',\n",
              " '_STRUCT_TM_ITEMS',\n",
              " '__doc__',\n",
              " '__loader__',\n",
              " '__name__',\n",
              " '__package__',\n",
              " '__spec__',\n",
              " 'altzone',\n",
              " 'asctime',\n",
              " 'clock',\n",
              " 'clock_getres',\n",
              " 'clock_gettime',\n",
              " 'clock_gettime_ns',\n",
              " 'clock_settime',\n",
              " 'clock_settime_ns',\n",
              " 'ctime',\n",
              " 'daylight',\n",
              " 'get_clock_info',\n",
              " 'gmtime',\n",
              " 'localtime',\n",
              " 'mktime',\n",
              " 'monotonic',\n",
              " 'monotonic_ns',\n",
              " 'perf_counter',\n",
              " 'perf_counter_ns',\n",
              " 'process_time',\n",
              " 'process_time_ns',\n",
              " 'pthread_getcpuclockid',\n",
              " 'sleep',\n",
              " 'strftime',\n",
              " 'strptime',\n",
              " 'struct_time',\n",
              " 'thread_time',\n",
              " 'thread_time_ns',\n",
              " 'time',\n",
              " 'time_ns',\n",
              " 'timezone',\n",
              " 'tzname',\n",
              " 'tzset']"
            ]
          },
          "metadata": {},
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XQ-Ygx2Io79E",
        "outputId": "19f3333a-8de6-4d7f-cbb0-f3c414468a15"
      },
      "source": [
        "import time\n",
        "help(time.time)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Help on built-in function time in module time:\n",
            "\n",
            "time(...)\n",
            "    time() -> floating point number\n",
            "    \n",
            "    Return the current time in seconds since the Epoch.\n",
            "    Fractions of a second may be present if the system clock provides them.\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-si4MhbGsIP_",
        "outputId": "e590c9bd-e0f6-4d3d-973e-16d16a971910"
      },
      "source": [
        "time.time()  # devuelve los segundos transcurridos desde 1 enero 1970"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1635454622.3312757"
            ]
          },
          "metadata": {},
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OcDtooD-slYX",
        "outputId": "80b88516-5889-4a05-fa6e-d746d232f37e"
      },
      "source": [
        "print(f\"Han transcurrido {time.time()/60/60/24/365.25} años.\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Han transcurrido 51.824434596066084 años.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VJGMJNqKuthx"
      },
      "source": [
        "### Iterar un bucle durante 5 segundos\n",
        "Creamos un bucle que dure 5 segundos."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cdkC4rvItulZ"
      },
      "source": [
        "import time\n",
        "inicio = time.time()\n",
        "contador = 1\n",
        "while True:\n",
        "  print(f\"{contador}. Estamos jugando.....\")\n",
        "  contador += 1\n",
        "  final = time.time()\n",
        "  if final-inicio >= 5:\n",
        "    break\n",
        "\n",
        "print(\"Fin del juego.\")\n",
        "print(f\"Han transcurrido {final-inicio} segundos.\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "b1eO9AtSv0Yw"
      },
      "source": [
        "### Realizar todas las operaciones aritméticas que podamos durante 10 segundos\n",
        "* Durante 10 segundos el ordenador te plantea operaciones matemáticas sencillas de suma o de multiplicación.\n",
        "* Por cada acierto se gana un punto.\n",
        "* Si no se acierta no se gana nada.\n",
        "* Al final nos dice los puntos obtenidos."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CO_n-sWUEFRs"
      },
      "source": [
        "#### Solución 1"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3CD_JBP8wgPJ",
        "outputId": "7dfafa26-f89b-488f-b1b8-b58380f3e9e6"
      },
      "source": [
        "import time\n",
        "import random\n",
        "print(\"*************** CONCURSO DE CÁLCULO ***************\")\n",
        "print(\"Realiza todas las operciones matemáticas que puedas\")\n",
        "print(\"               durante diez segundos               \")\n",
        "print(\"***************************************************\")\n",
        "print()\n",
        "input(\"Para empezar pulsa ENTER.\")\n",
        "puntos = 0\n",
        "inicio = time.time()\n",
        "while time.time()-inicio<=10:\n",
        "  a = random.randint(1,10)\n",
        "  b = random.randint(1,10)\n",
        "  if random.randint(0,1):               # con un 50% de probabilidades sale 0 o sale 1\n",
        "    n = int(input(f\"{a}+{b}=\"))         # si sale 1 hacemos la suma\n",
        "    if n==a+b:\n",
        "      puntos += 1\n",
        "      print(f\"Correcto. Tiene {puntos} puntos.\")\n",
        "    else:\n",
        "      print(f\"Incorrecto. Tiene {puntos} puntos.\")\n",
        "  else:\n",
        "    n = int(input(f\"{a}*{b}=\"))         # si sale 0 hacemos el producto\n",
        "    if n==a*b:\n",
        "      puntos += 1\n",
        "      print(f\"Correcto. Tiene {puntos} puntos.\")\n",
        "    else:\n",
        "      print(f\"Incorrecto. Tiene {puntos} puntos.\")\n",
        "\n",
        "print(\"Tiempo terminado.\")\n",
        "print(f\"Has obtenido {puntos} puntos. \")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "*************** CONCURSO DE CÁLCULO ***************\n",
            "Realiza todas las operciones matemáticas que puedas\n",
            "               durante diez segundos               \n",
            "***************************************************\n",
            "\n",
            "Para empezar pulsa ENTER.\n",
            "7*2=14\n",
            "Correcto. Tiene 1 puntos.\n",
            "6*9=4\n",
            "Incorrecto. Tiene 1 puntos.\n",
            "4*1=4\n",
            "Correcto. Tiene 2 puntos.\n",
            "1*2=2\n",
            "Correcto. Tiene 3 puntos.\n",
            "2+8=10\n",
            "Correcto. Tiene 4 puntos.\n",
            "Tiempo terminado.\n",
            "Has obtenido 4 puntos. \n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-eA7Jjw7EJAa"
      },
      "source": [
        "#### Solución 2"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "L3PxaDy5v9EK",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2aad0741-7922-4fb4-f4fe-e65c13aba0fa"
      },
      "source": [
        "import time\n",
        "import random\n",
        "print(\"*************** CONCURSO DE CÁLCULO ***************\")\n",
        "print(\"Realiza todas las operciones matemáticas que puedas\")\n",
        "print(\"               durante diez segundos               \")\n",
        "print(\"***************************************************\")\n",
        "print()\n",
        "input(\"Para empezar pulsa ENTER.\")\n",
        "puntos = 0\n",
        "inicio = time.time()\n",
        "while time.time()-inicio<=10:\n",
        "  a = random.randint(1,10)\n",
        "  b = random.randint(1,10)\n",
        "  op = random.choice([\"+\",\"*\"])  # operación + o * con un 50% de probabilidades\n",
        "  if op==\"+\":\n",
        "    resultado = a+b\n",
        "  elif op==\"*\":\n",
        "    resultado = a*b\n",
        "  print(a,op,b,\"=\",end=\" \")\n",
        "  respuesta = int(input())\n",
        "  if respuesta == resultado:\n",
        "    puntos += 1\n",
        "    print(f\"Correcto. Tienes {puntos} puntos.\")\n",
        "  else:\n",
        "    print(f\"Incorrecto. Tienes {puntos} puntos.\")\n",
        "\n",
        "print(\"Tiempo terminado.\")\n",
        "print(f\"Has obtenido {puntos} puntos. \")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "*************** CONCURSO DE CÁLCULO ***************\n",
            "Realiza todas las operciones matemáticas que puedas\n",
            "               durante diez segundos               \n",
            "***************************************************\n",
            "\n",
            "Para empezar pulsa ENTER.\n",
            "9 * 8 = 5\n",
            "Incorrecto. Tienes 0 puntos.\n",
            "5 * 3 = 15\n",
            "Correcto. Tienes 1 puntos.\n",
            "5 * 4 = 20\n",
            "Correcto. Tienes 2 puntos.\n",
            "5 + 10 = 15\n",
            "Correcto. Tienes 3 puntos.\n",
            "Tiempo terminado.\n",
            "Has obtenido 3 puntos. \n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "v_AlYzMUFfQe"
      },
      "source": [
        "## Función ```time.sleep()```\n",
        "Detiene la ejecución del programa durante unos segundos."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Fh3WFUiOFxq7",
        "outputId": "08b68abc-6939-4e1a-b419-37b73378ad01"
      },
      "source": [
        "import time\n",
        "print(\"Comienzo del programa.\")\n",
        "time.sleep(5)                       # el programa queda detenido durante 5 segundos\n",
        "print(\"Final del programa.\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Comienzo del programa.\n",
            "Final del programa.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Ube2kuesGNLU",
        "outputId": "e4c9668b-9fc1-4506-92fb-ad927e62cc24"
      },
      "source": [
        "import time\n",
        "print(\"Comienzo del programa.\")\n",
        "inicio = time.time()\n",
        "time.sleep(.5)                       # el programa queda detenido durante medio segundo\n",
        "fin = time.time()\n",
        "print(\"Final del programa.\")\n",
        "print(f\"Tiempo detenido {fin-inicio}.\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Comienzo del programa.\n",
            "Final del programa.\n",
            "Tiempo detenido 0.5007481575012207.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_nGpidYjG361"
      },
      "source": [
        "### Cuenta atrás de 10 segundos\n",
        "* Crear una cuenta atras del diez al cero: 10,9,8,7,6,5,4,3,2,1, ¡¡¡Lanzamiento!!!\n",
        "* De forma que aparezca un número cada segundo.\n",
        "* Al final medir el tiempo que ha tardado.\n",
        "* Debería tardar 10 segundos y algunas décimas o centésimas más."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "A6dGxNNyHVAN",
        "outputId": "2469c2d5-b25f-4344-d38c-d5180e5ba381"
      },
      "source": [
        "import time\n",
        "inicio = time.time()\n",
        "for i in range(10,0,-1):\n",
        "  print(i)\n",
        "  time.sleep(1)\n",
        "\n",
        "fin = time.time()\n",
        "print(\"¡¡¡Lanzamiento!!!\")\n",
        "print(f\"El proceso ha tardado {fin-inicio} segundos.\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "10\n",
            "9\n",
            "8\n",
            "7\n",
            "6\n",
            "5\n",
            "4\n",
            "3\n",
            "2\n",
            "1\n",
            "¡¡¡Lanzamiento!!!\n",
            "El proceso ha tardado 10.012050867080688 segundos.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "e2RdpckPJtkK"
      },
      "source": [
        "## Medir el tiempo de ejecución de un programa\n",
        "Con la función ```time.perf_counter()``` podemos medir el tiempo de ejecución de un procedimiento.  \n",
        "Podemos programar una tarea mediante dos códigos distintos y ver cuál es más rápido."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PuR_AScIKi5o"
      },
      "source": [
        "### Sumar serie de números con ```while``` y con ```for```\n",
        "Sumar los números entre uno y un millón usando ambos bucles y ver cúal tarda menos."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "j05rmF_SKkcG"
      },
      "source": [
        "#### Versión 1. Con ```while```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_eXO9uIpKFTn",
        "outputId": "4265a2c6-86c5-4cbf-b35d-f010a0db500d"
      },
      "source": [
        "import time\n",
        "inicio = time.perf_counter()\n",
        "suma = 0\n",
        "i = 1\n",
        "while i <= 1_000_000:\n",
        "  suma += i\n",
        "  i += 1\n",
        "\n",
        "fin = time.perf_counter()\n",
        "print(f\"La suma es {suma}.\")\n",
        "print(f\"El tiempo empleado es de {fin-inicio} segundos.\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "La suma es 500000500000.\n",
            "El tiempo empleado es de 0.22466365299987956 segundos.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cvGJ5JYqKtpY"
      },
      "source": [
        "#### Versión 2. Con ```for```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3lVgTkF3KfeB",
        "outputId": "f700bff8-cabe-4a17-bbff-152d6d03fb91"
      },
      "source": [
        "import time\n",
        "inicio = time.perf_counter()\n",
        "suma = 0\n",
        "for i in range(1,1_000_001):\n",
        "  suma += i\n",
        "\n",
        "fin = time.perf_counter()\n",
        "print(f\"La suma es {suma}.\")\n",
        "print(f\"El tiempo empleado es de {fin-inicio} segundos.\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "La suma es 500000500000.\n",
            "El tiempo empleado es de 0.13868624799943063 segundos.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "smaEHlpXMr5R"
      },
      "source": [
        "## Función ```random.shuffle()```\n",
        "Baraja aleatoriamente los elementos de una lista."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "iwwcoSFfM4r7",
        "outputId": "1b79d022-2576-49c5-8aea-e2ebfcc5f18c"
      },
      "source": [
        "import random\n",
        "lista = [1,2,3,4,5,6]\n",
        "random.shuffle(lista)  # baraja la lista, no devuelve una lista nueva\n",
        "print(lista)\n",
        "random.shuffle(lista)  # cada vez que ejecutamos la función baraja la lista\n",
        "lista"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[3, 4, 1, 2, 6, 5]\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[2, 6, 5, 4, 3, 1]"
            ]
          },
          "metadata": {},
          "execution_count": 25
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rzsxskj-OGiB"
      },
      "source": [
        "### Función ```random.sample()```\n",
        "* Dada una lista, devuelve un cierto número de valores de la lista elegidos de forma aleatoria.\n",
        "* Tiene dos argumentos la lista y el número de elementos que deseamos obtener.\n",
        "* En este caso si devuelve una lista distinta a la original."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Ksi1WKm3Orto",
        "outputId": "10ce53b3-4532-4797-b768-2f00521e4951"
      },
      "source": [
        "import random\n",
        "lista = [10,20,30,40,50,60,70,80,90]\n",
        "random.sample(lista,3)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[20, 60, 50]"
            ]
          },
          "metadata": {},
          "execution_count": 28
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fTSq5-3uPGyt",
        "outputId": "7d5df958-6c8d-42ff-abb3-6c4c34e974db"
      },
      "source": [
        "muestra = random.sample(lista,3)  # acúa sobre la lista original\n",
        "muestra                           # la lista que devuelve se puede asignar a una variable"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[90, 50, 60]"
            ]
          },
          "metadata": {},
          "execution_count": 30
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "d7V7AvmlP3AZ"
      },
      "source": [
        "### Juego: memoriza los colores\n",
        "* Muestra cuatro colores durante 3 segundos\n",
        "* Debes responder recordando los cuatro colores en su orden\n",
        "* Si aciertas, sumas un punto y los vuelve a mostrar en otro oden\n",
        "* Para finalizar el juego debes pulsar ENTER al responder a los cuatro colores."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "b17DYh1epCzy",
        "outputId": "ba287345-43b4-4d8d-dc08-a31e53806cbb"
      },
      "source": [
        "from IPython.display import clear_output\n",
        "from random import shuffle \n",
        "from time import sleep\n",
        "print(\"********* Memoriza los colores *********\")\n",
        "colores = ['rojo','verde','azul','amarillo']\n",
        "puntos = 0\n",
        "while True:\n",
        "  shuffle(colores)\n",
        "  print(colores)\n",
        "  sleep(3)                                                  # espera 3 segundos\n",
        "  clear_output()                                            # limpia la salida de pantalla\n",
        "  c1=input(\"Introduzca el color 1: \")\n",
        "  c2=input(\"Introduzca el color 2: \")\n",
        "  c3=input(\"Introduzca el color 3: \")\n",
        "  c4=input(\"Introduzca el color 4: \")\n",
        "  if colores==[c1,c2,c3,c4]:\n",
        "    puntos += 1\n",
        "    print(f\"Lleva {puntos} puntos.\")\n",
        "  elif [c1,c2,c3,c4]==['','','','']:              # si pulsamos ENTER en todos los colores finalizará el loop\n",
        "    break\n",
        "print(f\"Los puntos totales conseguidos son: {puntos}.\")"
      ],
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Introduzca el color 1: \n",
            "Introduzca el color 2: \n",
            "Introduzca el color 3: \n",
            "Introduzca el color 4: \n",
            "Los puntos totales conseguidos son: 3.\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vTkDbYCAoAMY"
      },
      "source": [
        "### Reto 9.2. Mejora el juego de los colores\n",
        "* Los colores disponibles serán 10 y de ellos se mostrarán aleatoriamente 4\n",
        "* Por cada color introducido si no es correcto, se avisa de ello y no se siguen pidiendo los demás colores.\n",
        "\n",
        "colores = ['rojo','verde','azul','amarillo','naranja','rosa','marrón','violeta','negro','blanco']"
      ]
    }
  ]
}