IntroPython_EstructurasControl.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Estructuras de control en Python\n",
    "\n",
    "Las estructuras de control permiten variar la forma en que se ejecutan por defecto las instrucciones (una a continuación de otra).\n",
    "\n",
    "Cuando se programa a muy bajo nivel (código máquina, lenguaje ensamblador) básicamente se dispone de los 'saltos' (*jump* o *go to*) que pueden ser condicionales o incondicionales para variar el flujo de ejecución, pero esta forma de trabajar es propensa a errores, dificulta entender el código (da lugar a código a veces llamado *spaguetti*). Por ese motivo, los lenguajes de alto nivel utilizan unas **estructuras** de control que, junto al uso de funciones, dan lugar a lo que se conoce como [programación estructurada](https://es.wikipedia.org/wiki/Programaci%C3%B3n_estructurada).\n",
    "\n",
    "Normalmente las estructuras de control se clasifican en 2 tipos:\n",
    "\n",
    "1. De selección (destacan las condicionales `if/elif/else`).\n",
    "2. De iteración (bucles `while` y `for in`).\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Recordatorio sobre la sintaxis de las estructuras en Python\n",
    "\n",
    "Recordamos que en Python se utiliza la intendación (o sangrado) para marcar la estructura allí donde esto tenga sentido, es decir:\n",
    "\n",
    "- Al definir funciones:\n",
    "\n",
    "```python\n",
    "def f(x):\n",
    "    y = x**2\n",
    "    return y\n",
    "```\n",
    "\n",
    "- Al definir clases:\n",
    "\n",
    "```python\n",
    "class Circulo:\n",
    "    def __init__(self, radio):\n",
    "        self.radio = radio\n",
    "```\n",
    "\n",
    "- En las estructuras de control de flujo:\n",
    "\n",
    "```python\n",
    "for i in [1,2,3]:\n",
    "    print(\"i = \",i)\n",
    "```\n",
    "Es importante tener en cuenta que no hay ningún problema en poner una estructura dentro de otra. Esto se llama \"anidar\" (nest, en inglés) de modo que es habitual encontrarse con bucles dentro de bucles, condifionales dentro de bucles, bucles dentro de condicionales, etc...\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Estructuras control para la selección"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "introduce un número entero:7\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "num = int(input(\"introduce un número entero:\")) # ignoramos errores de momento\n",
    "es_par = num % 2 == 0 # es_par es un valor bool (True o False)\n",
    "print(es_par)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "introduce un número entero:3\n",
      "El número 3 es impar\n"
     ]
    }
   ],
   "source": [
    "# queremos imprimir \"El número ... es par\" o \"El número ... es impar\"\n",
    "num = int(input(\"introduce un número entero:\")) # ignoramos errores de momento\n",
    "es_par = num % 2 == 0 # es_par es un valor bool (True o False)\n",
    "if es_par:\n",
    "    print(f\"El número {num} es par\")\n",
    "else:\n",
    "    print(f\"El número {num} es impar\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La instrucción condicional tiene esta forma:\n",
    "\n",
    "```python\n",
    "if condicion:\n",
    "    bloque de instrucciones\n",
    "    bloque de instrucciones\n",
    "```\n",
    "\n",
    "Puede llevar un `else` opcional:\n",
    "\n",
    "```python\n",
    "if condicion:\n",
    "    bloque de instrucciones\n",
    "    bloque de instrucciones\n",
    "else:\n",
    "    bloque de instrucciones\n",
    "    bloque de instrucciones\n",
    "```\n",
    "\n",
    "El uso de `elif` permite hacer `else if:` sin necesidad de ir aumentando la indentación:\n",
    "\n",
    "```python\n",
    "if condicion:\n",
    "    bloque de instrucciones\n",
    "    bloque de instrucciones\n",
    "elif condicion:\n",
    "    bloque de instrucciones\n",
    "    bloque de instrucciones\n",
    "```\n",
    "\n",
    "Por ejemplo, veamos un ejemplo que genera las palabras 'suspenso', 'aprobado', 'notable' o 'sobresaliente' según la nota (aprobado con 5, notable con 7, sobresaliente con 9):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Escribe tu nota entre 0 y 10:7.6\n",
      "La nota 7.6 corresponde a un notable\n"
     ]
    }
   ],
   "source": [
    "nota = float(input(\"Escribe tu nota entre 0 y 10: \")) # ignoramos errores de momento\n",
    "if nota<5:\n",
    "    calif = 'suspenso'\n",
    "elif nota<7:\n",
    "    calif = 'aprobado'\n",
    "elif nota<9:\n",
    "    calif = 'notable'\n",
    "else:\n",
    "    calif = 'sobresaliente'\n",
    "print(f'La nota {nota} corresponde a un {calif}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### La expresión condicional\n",
    "\n",
    "Además de las instrucciones de tipo condicional tenemos la **expresión condicional**:\n",
    "\n",
    "La siguiente expresión:\n",
    "\n",
    "```python\n",
    "valor1 if condicion else valor2\n",
    "```\n",
    "\n",
    "Devuelve `valor1` si `condicion` es cierto (*truthy*) o bien `valor2` en caso contrario.\n",
    "\n",
    "¡Se puede utilizar en cualquier sitio donde se pueda poner una expresión!\n",
    "\n",
    "Ejemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "introduce un número entero:5\n",
      "El número 5 es impar\n"
     ]
    }
   ],
   "source": [
    "# queremos imprimir \"El número ... es par\" o \"El número ... es impar\"\n",
    "num = int(input(\"introduce un número entero:\")) # ignoramos errores de momento\n",
    "par_o_impar = \"par\" if num % 2 == 0 else \"impar\"\n",
    "print(f\"El número {num} es {par_o_impar}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Switch\n",
    "\n",
    "Algunos lenguajes de programación (C, Java,...) tienen una estructura de selección llamada `switch` que no está disponible *tal cual* en Python.\n",
    "\n",
    "Por si alguien la echa en falta, además de la posibilidad de utilizar una secuencia de `if elif elif ... else` conviene saber que en muchos casos se pueden utilizar diccionarios en su lugar.\n",
    "\n",
    "Ejemplo: pedir el mes en formato numérico (un valor entre 1 y 12) y mostrarlo en texto (en castellano):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Introduce el mes como número entre 1 y 12: 5\n",
      "El mes 5 se corresponde a mayo\n"
     ]
    }
   ],
   "source": [
    "mes = int(input(\"Introduce el mes como número entre 1 y 12: \"))\n",
    "dictmes = {1:\"enero\", 2:\"febrero\", 3:\"marzo\", 4:\"abril\",\n",
    "           5:\"mayo\",   6:\"junio\",   7:\"julio\", 8:\"agosto\",\n",
    "           9:\"septiembre\", 10:\"octubre\", 11:\"noviembre\", 12:\"diciembre\"}\n",
    "print(f\"El mes {mes} se corresponde a {dictmes[mes]}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Utilizar `dictmes` es mucho mejor que recurrir a algo tipo:\n",
    "\n",
    "```python\n",
    "if mes == 1:\n",
    "  txt = 'enero'\n",
    "elif mes == 2:\n",
    "  txt = 'febrero'\n",
    "  ...\n",
    "```\n",
    "\n",
    "El uso de diccionarios para estructuras de selección se puede flexibilizar bastante mediante:\n",
    "\n",
    "- El uso de funciones (ver tutorial sobre \"orden superior\")\n",
    "- Hay diccionarios con valor por defecto (la clase `collections.defaultdict`)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Estructuras de control para la iteración"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La instrucción `while` permite repetir un bloque de instrucciones *mientras* se cumpla cierta condición, la sintaxis es:\n",
    "\n",
    "```python\n",
    "while condicion:\n",
    "    bloque de instrucciones # esta parte\n",
    "    bloque de instrucciones # se llama\n",
    "    bloque de instrucciones # cuerpo del bucle\n",
    "```\n",
    "\n",
    "A tener en cuenta:\n",
    "\n",
    "- Si la condición es inicialmente falsa, no se ejecuta ninguna vez.\n",
    "- Si la condición fuese siempre cierta, sería un *bucle infinito*.\n",
    "- La instrucción `break` dentro del cuerpo hace que salgamos inmediatamente de él. Por eso sólo tiene sentido poner un break dentro de una instrucción condicional.\n",
    "- La instrucción `continue` hace que volvamos inmediatamente arriba (a comprobar la condición) sin terminar de ejecutar el resto del cuerpo del bucle. Por eso, al igual que con `break`, sólo tiene sentido dentro de una instrucción condicional (`if`...).\n",
    "- La instrucción `while` puede llevar un `else` opcional al final. El cuerpo del `else` se ejecutará al final siempre y cuando no hayamos salido con un `break`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Introduce un entero entre 0 y 10: 7\n",
      "7 x  0 =   0\n",
      "7 x  1 =   7\n",
      "7 x  2 =  14\n",
      "7 x  3 =  21\n",
      "7 x  4 =  28\n",
      "7 x  5 =  35\n",
      "7 x  6 =  42\n",
      "7 x  7 =  49\n",
      "7 x  8 =  56\n",
      "7 x  9 =  63\n",
      "7 x 10 =  70\n"
     ]
    }
   ],
   "source": [
    "n = int(input(\"Introduce un entero entre 0 y 10: \"))\n",
    "i = 0\n",
    "while i<=10:\n",
    "    # las CADENAS CON FORMATO se vieron en el tutorial de cadenas:\n",
    "    print(f\"{n} x {i:2} = {n*i:3}\")\n",
    "    i = i+1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Introduce un entero entre 0 y 10: hola\n",
      "Error: no es un entero válido\n",
      "Introduce un entero entre 0 y 10: 30\n",
      "Error: valor fuera de rango\n",
      "Introduce un entero entre 0 y 10: 8\n",
      "El valor introducido es 8\n"
     ]
    }
   ],
   "source": [
    "# Pedir un número entero entre 0 y 10 y asegurarse de que es correcto:\n",
    "n = None\n",
    "while n is None or not(0<=n<=10):\n",
    "    try: # las excepciones se irán viendo con el uso...\n",
    "      n = int(input(\"Introduce un entero entre 0 y 10: \"))\n",
    "      if not(0<=n<=10):\n",
    "          print(\"Error: valor fuera de rango\")\n",
    "    except ValueError:\n",
    "        print(\"Error: no es un entero válido\")\n",
    "print(\"El valor introducido es\",n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### La instrucción `for ... in ...:`\n",
    "\n",
    "La sintaxis es:\n",
    "\n",
    "```python\n",
    "for variable in iterable:\n",
    "    bloque de instrucciones\n",
    "    bloque de instrucciones\n",
    "    ...\n",
    "```\n",
    "\n",
    "Ejemplos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "20\n",
      "30\n"
     ]
    }
   ],
   "source": [
    "for i in [10,20,30]:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "3\n",
      "6\n",
      "9\n",
      "12\n",
      "15\n",
      "18\n",
      "21\n",
      "24\n",
      "27\n"
     ]
    }
   ],
   "source": [
    "for i in range(0,30,3): # de 0 a 30 (no inclusive) de 3 en 3\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Es posible \"desempaquetar\" (*unboxing*) los valores devueltos en más de una variable de la manera siguiente:\n",
    "\n",
    "```python\n",
    "for var1,var2,...,varN in iterable:\n",
    "    bloque de instrucciones\n",
    "    bloque de instrucciones\n",
    "    ...\n",
    "```\n",
    "\n",
    "Ejemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cuesta 100 euros\n",
      "Cuesta 200 dólares\n",
      "Cuesta 30 libras\n"
     ]
    }
   ],
   "source": [
    "for pvp,tipo in [(100,'euros'),(200,'dólares'),(30,'libras')]:\n",
    "    print(\"Cuesta\",pvp,tipo)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En el ejemplo anterior la pareja `pvp,tipo` es en el fondo una tupla, lo que pasa es que los paréntesis son opcionales:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cuesta 100 euros\n",
      "Cuesta 200 dólares\n",
      "Cuesta 30 libras\n"
     ]
    }
   ],
   "source": [
    "for (pvp,tipo) in [(100,'euros'),(200,'dólares'),(30,'libras')]:\n",
    "    print(\"Cuesta\",pvp,tipo)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En Python hay varias cosas \"iterables\" que se pueden utilizar en un `for`:\n",
    "\n",
    "- Listas\n",
    "- Tuplas\n",
    "- Cadenas\n",
    "- `range`\n",
    "- `enumerate`\n",
    "- `reversed`\n",
    "- `sorted`\n",
    "- `zip`\n",
    "- ...\n",
    "\n",
    "Ejemplo:\n",
    "\n",
    "Tenemos 2 listas del mismo tamaño y queremos mostrar un elemento de cada una:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Juan tiene 12 años\n",
      "Marta tiene 30 años\n",
      "Julia tiene 15 años\n",
      "María tiene 25 años\n",
      "Joaquín tiene 48 años\n"
     ]
    }
   ],
   "source": [
    "nombres = ['Juan', 'Marta', 'Julia', 'María', 'Joaquín']\n",
    "edades = [12, 30, 15, 25, 48]\n",
    "\n",
    "for i in range(len(nombres)):\n",
    "    print(nombres[i],\"tiene\",edades[i],\"años\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Juan tiene 12 años\n",
      "Marta tiene 30 años\n",
      "Julia tiene 15 años\n",
      "María tiene 25 años\n",
      "Joaquín tiene 48 años\n"
     ]
    }
   ],
   "source": [
    "nombres = ['Juan', 'Marta', 'Julia', 'María', 'Joaquín']\n",
    "edades = [12, 30, 15, 25, 48]\n",
    "\n",
    "for i,nombre in enumerate(nombres):\n",
    "    print(nombre,\"tiene\",edades[i],\"años\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Juan tiene 12 años\n",
      "Marta tiene 30 años\n",
      "Julia tiene 15 años\n",
      "María tiene 25 años\n",
      "Joaquín tiene 48 años\n"
     ]
    }
   ],
   "source": [
    "nombres = ['Juan', 'Marta', 'Julia', 'María', 'Joaquín']\n",
    "edades = [12, 30, 15, 25, 48]\n",
    "\n",
    "for nombre,edad in zip(nombres,edades):\n",
    "    print(nombre,\"tiene\",edad,\"años\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dime un nombre: Julia\n",
      "Julia no se ha encontrado\n",
      "Julia no se ha encontrado\n",
      "Julia tiene 15 años\n"
     ]
    }
   ],
   "source": [
    "nombres = ['Juan', 'Marta', 'Julia', 'María', 'Joaquín']\n",
    "edades = [12, 30, 15, 25, 48]\n",
    "\n",
    "quien = input(\"Dime un nombre: \")\n",
    "for nombre,edad in zip(nombres,edades):\n",
    "    if nombre == quien:\n",
    "        print(nombre,\"tiene\",edad,\"años\")\n",
    "        break # no tiene sentido continuar una vez encontrado\n",
    "    else:\n",
    "        print(quien,\"no se ha encontrado\") # MAL MAL MAL MAL ¿por qué?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dime un nombre: Juan\n",
      "Juan tiene 12 años\n"
     ]
    }
   ],
   "source": [
    "nombres = ['Juan', 'Marta', 'Julia', 'María', 'Joaquín']\n",
    "edades = [12, 30, 15, 25, 48]\n",
    "\n",
    "quien = input(\"Dime un nombre: \")\n",
    "for nombre,edad in zip(nombres,edades):\n",
    "    if nombre == quien:\n",
    "        print(nombre,\"tiene\",edad,\"años\")\n",
    "        break # no tiene sentido continuar una vez encontrado\n",
    "else: # OJO! el else está asociado al for\n",
    "    print(quien,\"no se ha encontrado\") # se ejecuta si no hemos salido con break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Juan': 12, 'Marta': 30, 'Julia': 15, 'María': 25, 'Joaquín': 48}"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# No obstante, hay formas más elegantes de resolver esto...\n",
    "nom2edad = dict(zip(nombres, edades))\n",
    "nom2edad"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dime un nombre: Juan\n",
      "Juan tiene 12 años\n"
     ]
    }
   ],
   "source": [
    "quien = input(\"Dime un nombre: \")\n",
    "if quien in nom2edad:\n",
    "    print(quien,\"tiene\",nom2edad[quien],\"años\")\n",
    "else:\n",
    "    print(quien,\"no se ha encontrado\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Nota:** Es posible preguntar `quien in nombre` pero resulta más eficiente `quien in nom2edad` porque consultar si una clave pertenece a un diccionario tiene un coste constante y buscar un elemento en una lista tiene un coste lineal.\n",
    "\n",
    "Es más, si solamente hubiésemos tenido el diccionario `nom2edad` en lugar de las listas `nombre` y `edades`, también podríamos haber mostrado todos los nombres con sus edades (ver también el tutorial de diccionarios):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Juan 12\n",
      "Marta 30\n",
      "Julia 15\n",
      "María 25\n",
      "Joaquín 48\n"
     ]
    }
   ],
   "source": [
    "for nom,edad in nom2edad.items():\n",
    "    print(nom,edad)"
   ]
  }
 ],
 "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.6.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}