Cuadernos/0501_while.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tema 5: Bucles (I)\n",
    "Una de las cosas más útiles de la programación son los bucles. Seguro que ya te ha pasado que te hartas de escribir la misma línea o una línea muy parecida tropecientas veces. La mayoría lo que hacemos en esa situación es copiar y pegar y cambiar lo que haga falta. Pero aun así es un rollo, y lo peor es que es muy fácil que nos equivoquemos.\n",
    "\n",
    "¿Y si no tuviéramos que hacerlo? Seríamos mucho más rápidos; además, no habría lugar a error. Así que, si se puede automatizar y nos hace más productivos, seguro que hay otra forma de hacerlo. Pues así es; casi siempre en programación vamos a poder decir que la anterior oración es cierta.\n",
    "\n",
    "Hasta ahora, si queríamos que una misma instrucción se ejecutara varias veces teníamos que escribirla otras tantas. Pero los bucles nos van a permitir escribir una instrucción o conjunto de instrucciones una sola vez y que se ejecute el número de veces que queramos.\n",
    "\n",
    "Hay 2 tipos de bucles: los que se escriben con la instrucción `while` y los que se escriben con `for`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Bucles con `while`\n",
    "El esquema que sigue la instrucción `while` es similar al de `if`:\n",
    "\n",
    "    <inicialización_del_bucle>\n",
    "    while <condición>:\n",
    "        <instrucciones_dentro_del_while>\n",
    "    <resto_del_programa>\n",
    "\n",
    "Lo que hacemos cuando usamos `while` es decirle al intérprete que, mientras se cumpla una condición, ejecute las instrucciones dentro del `while`, y cuando deje de darse esa condición continúe con el resto del programa.\n",
    "\n",
    "Por ejemplo, podemos escribir las siguientes líneas para imprimir los números del 1 al 5:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "i = 1\n",
    "while i <= 5:\n",
    "    print(i)\n",
    "    i = i + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lo primero que hacemos es inicializar el bucle, es decir, declarar una variable `i` con un valor inicial `1`. Ahora que ya existe una variable en nuestro entorno, podemos crear un bucle con `while` en el que vayamos incrementando su valor en una unidad cada vez. Si no inicializamos el bucle, no tenemos nada con lo que trabajar en el `while`.\n",
    "\n",
    "En la segunda línea creamos el bucle con la condición de que `i` sea igual o menor que 5. Como en este punto del programa `i` es igual a 1, el programa entra en el bucle y ejecuta las instrucciones que hay dentro de él.\n",
    "\n",
    "La primera instrucción dentro del `while` es imprimir el valor que contiene la variable `i`, que sigue valiendo 1, así que se imprime un 1.\n",
    "\n",
    "En la siguiente línea ya cambiamos el valor de la variable; le sumamos 1. ¿Recuerdas lo que dijimos sobre el orden de lectura en el cuaderno 3 del tema 2? Te lo refresco: el intérprete lee de derecha a izquierda, así que primero calcula la expresión a la derecha de la asignación (`i` (que todavía vale 1) `+ 1`) y luego se lo asigna a `i`. Así que al terminar de ejecutarse esta línea, `i` vale 2.\n",
    "\n",
    "Cuando se ejecuta la última instrucción del bucle, se vuelve a evaluar la condición con la que lo hemos abierto. `i` vale 2, así que la condición sigue siendo cierta y el programa no se sale del bucle. Se vuelve a ejecutar la primera instrucción, volvemos a llegar al final, evaluamos de nuevo la condición, así que seguimos dentro del bucle y ejecutamos las instrucciones... hasta que llega un momento en que la última instrucción hace que `i` valga 6 y el programa se salga del bucle porque deja de cumplirse la condición. Pero en el camino hemos escrito los números que queríamos imprimir."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Nombre del índice\n",
    "Por convención, el nombre de la variable que nos va a servir para iterar por el bucle es `i` (de _index_, «índice»), pero podríamos llamarla de cualquier manera. El siguiente ejemplo es exactamente igual al anterior solo que el índice lo hemos llamado `numerito`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "numerito = 1\n",
    "while numerito <= 5:\n",
    "    print(numerito)\n",
    "    numerito = numerito + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Un error común: bucle infinito\n",
    "Es muy importante que al final de las instrucciones que van dentro del `while` permitamos que en alguna ocasión la condición deje de cumplirse. Si no, nuestro programa entrará en un bucle infinito. No arrojará un error, pero nunca terminará de ejecutarse, así que tendremos que pararlo. Así que, como truco, si tu programa tarda más de lo habitual en ejecutarse, piensa si ha podido entrar en un bucle infinito.\n",
    "\n",
    "En la terminal, para parar un proceso puedes hacer Ctrl + C.\n",
    "\n",
    "En los cuadernos, tendrás que seleccionar Kernel > Interrupt Kernel o, si eso no funciona, Restart.\n",
    "\n",
    "Puedes probar lo que pasa cuando se ejecuta un código con un bucle infinito ejecutando la siguiente celda, que imprimirá un 1 en distintas filas mientras la dejemos. Pero **¡cuidado con esta celda!** No te recomiendo ejecutarla si tu ordenador es lento."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "i = 1\n",
    "while i <= 5:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "¿Qué tendríamos que hacer para que nuestro programa no entre en un bucle infinito? Añadir, a las instrucciones dentro del bucle, una que permita al programa salir del bucle en algún momento. En este ejemplo, hacer que en algún momento `i` valga más de 5. Así que podemos añadir una línea en la que sumemos algo a `i`, para que se ejecute cada vez que el programa entra en el bucle."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "3\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "i = 1\n",
    "while i <= 5:\n",
    "    print(i)\n",
    "    i = i + 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Número de repeticiones ligado a otros fenómenos\n",
    "A veces, no sabemos exactamente cuántas veces vamos a querer que se repitan nuestras instrucciones, o queremos ligarlas a otros fenómenos distintos de progresiones aritméticas.\n",
    "\n",
    "Por ejemplo, podemos usar `while` para hacerle al usuario cuantas preguntas sean necesarias hasta que adivine un número:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Estoy pensando un número. ¿Adivinas cuál es?: 1\n",
      "Ese no es. Prueba otra vez: 8\n",
      "Ese no es. Prueba otra vez: 3\n",
      "Ese no es. Prueba otra vez: 44\n",
      "Ese no es. Prueba otra vez: 7\n",
      "¡Sí! Estaba pensando en el 7\n"
     ]
    }
   ],
   "source": [
    "num_secreto = 7\n",
    "\n",
    "num_propuesto = int(input(\"Estoy pensando un número. ¿Adivinas cuál es?: \"))\n",
    "\n",
    "while num_propuesto != num_secreto:\n",
    "    num_propuesto = int(input(\"Ese no es. Prueba otra vez: \"))\n",
    "\n",
    "print(\"¡Sí! Estaba pensando en el\", num_secreto)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El programa pide un número al usuario. Si lo adivina a la primera, el programa nunca entra en el bucle, porque no se cumple la condición. Si no, seguirá pidiendo números al usuario hasta que introduzca el 7. Compruébalo varias veces.\n",
    "\n",
    "Al principio del tema dijimos que los bucles nos permitían automatizar tareas repetitivas, pero que en cualquier caso podíamos diseñar lo mismo a mano, aunque fuera más lento y peligroso. Sin embargo, esto no es del todo cierto; el programa anterior no podríamos haberlo escrito sin `while`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ejercicios"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 050101\n",
    "¿Qué pasa si la condición que inicia un `while` no se cumple?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 050102\n",
    "Imagina que queremos crear nuestro propio calendario en una hoja de cálculo, empezando por este mes, marzo de 2022. Tendríamos que escribir un programa que en una línea imprima `martes 1`, una tabulación (que se escribe `\\t`), `miércoles 2`, otra tabulación, etc. hasta llegar al `domingo 6`. En la siguiente línea, tiene que escribir `lunes 7`, tabulación, `martes 8`, tabulación... y de nuevo hasta el domingo.\n",
    "\n",
    "De esta forma, lo que imprima el programa lo podremos copiar y pegar en una hoja de cálculo y tendremos nuestro calendario. Es decir, esta tendría que ser la estructura de lo que imprima:\n",
    "\n",
    "            martes 1\tmiércoles 2\tjueves 3\tviernes 4\tsábado 5\tdomingo 6\n",
    "    lunes 7\tmartes 8\tmiércoles 9\tjueves 10\tviernes 11\tsábado 12\tdomingo 13\n",
    "    ...\n",
    "\n",
    "Podemos usar este método para cualquier mes de cualquier año, cambiando solo un dato :)\n",
    "\n",
    "Escribe el programa usando `while`. Deberás inicializar el bucle dándole a `i` el valor `1`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 050103\n",
    "Puede que hayas fantaseado alguna vez con hacer un programa que pida al usuario escribir un mensaje y que solo lo acepte si tiene una ortografía perfecta. Bueno, todavía no sabemos hacer un corrector ortográfico completo, pero sí podemos usar los métodos de las strings (que vimos en el cuaderno 0202) para detectar si un mensaje:\n",
    "- está escrito todo en mayúsculas (`.islower()`);\n",
    "- está escrito todo en minúsculas (`.isupper()`); o\n",
    "- solo contiene números (`.isnumeric()`).\n",
    "\n",
    "Con un bucle con `while`, escribe un programa que pregunte al usuario qué tal el día y que, en los supuestos anteriores, le diga qué está mal y le vuelva a pedir el mensaje, pero esta vez cumpliendo las normas ortográficas. Puede decir, por ejemplo, si está escrito en mayúsculas, que no hace falta que grite; y si está en minúsculas, que no estamos en Whatsapp, etc. Puedes dejar volar tu imaginación :)\n",
    "\n",
    "Cuando el mensaje no cumpla ninguno de los supuestos, entenderemos que supera nuestros estándares de calidad, saldremos del bucle y le diremos que aceptamos su mensaje."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}