{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Control de flujo\n",
    "\n",
    "Hasta ahora hemos programado en Python intrucciones sencillas que solo tenían en cuenta una posibilidad. No evaluábamos nada, simplemente dábamos órdenes y Python obedecía. Como mucho, cuando cometíamos algún error de sintaxis, Python se quejaba, sin más. \n",
    "\n",
    "A partir de ahora vamos a aprender a manejar el **control de flujo**. Vamor a tener en cuenta resultados múltiples y vamos a seleccionar uno concreto dependiendo del valor que tengan las variables o de lo que esté ocurriendo en el programa en un momento concreto.\n",
    "\n",
    "## Comparadores\n",
    "\n",
    "Los elementos más sencillos del control de flujo son los **comparadores**:\n",
    "\n",
    "- Igual a `==`.\n",
    "- No es igual a `!=`.\n",
    "- Menor que `<`.\n",
    "- Menor o igual que `<=`.\n",
    "- Mayor que `>`.\n",
    "- Mayor o igual que `>=`.\n",
    "\n",
    "¡OJO! No confundas el comparador de igualdad `==` con el símbolo `=` que utilizamos para asignar valores a variables.\n",
    "\n",
    "Cuando utilizamos un comparador para comparar dos expresiones, el resultado que nos devuelve la comparación es un valor booleano: `True` o `False`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n",
      "True\n",
      "Hola Emilio\n",
      "False\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "# asignamos unos cuantos valores a variables\n",
    "numero1 = 2\n",
    "numero2 = 34\n",
    "\n",
    "print(numero1 == numero2)\n",
    "print(numero1 != numero2)\n",
    "print(numero1 == numero1)\n",
    "print('Hola Emilio')\n",
    "print(numero2 <= 10)\n",
    "\n",
    "print(19 >= (10 * numero1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Condicionales\n",
    "\n",
    "En Python podemos evaluar **condiciones** con la intrucción `if`. `if` forma lo que se denomina un **bloque de código**, que tiene una sintaxis particular:\n",
    "\n",
    "    if COMPARACIÓN:\n",
    "        # si la comparación es True, ejecuta lo siguiente\n",
    "        INSTRUCCIONES_1\n",
    "\n",
    "\n",
    "Fíjate bien en dos cosas:\n",
    "\n",
    "- los bloques de código comienzan cuando una instrucción termina en dos puntos `:`\n",
    "- el código dentro del bloque aparece indentado o sangrado. \n",
    "\n",
    "Esta indentación se introduce pulsando el tabulador o tecleando espacios (habitualmente, cuatro espacios). Es muy importante mantener correctamente alineadas las instrucciones que aparecen dentro del mismo bloque de código. De lo contrario, podemos encontrar un error de sintaxis."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "¡Hey! Te llamas igual que yo.\n"
     ]
    }
   ],
   "source": [
    "nombre = 'Víctor'\n",
    "\n",
    "if nombre == 'Víctor':\n",
    "    print('¡Hey! Te llamas igual que yo.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 es igual a 5 veces 2\n"
     ]
    }
   ],
   "source": [
    "if 10 == 5*2:\n",
    "    print('10 es igual a 5 veces 2')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos evaluar condiciones más complejas definiciendo por ejemplo una alternativa cuando el resultado de la comparaciónn era `False`. Para ello, usamos instrucciones del tipo `if-else`, con la siguiente sintaxis:\n",
    "\n",
    "    if COMPARACIÓN:\n",
    "        # si la comparación es True, ejecuta lo siguiente\n",
    "        INSTRUCCIONES_1\n",
    "    else:\n",
    "        # por el contrario, si la comparación es False, ejecuta\n",
    "        INSTRUCCIONES_2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Deberías estar trabajando, si te dejan.\n"
     ]
    }
   ],
   "source": [
    "# prueba cambiando el valor asignado a la variable edad\n",
    "edad = 40\n",
    "\n",
    "if edad >= 65:\n",
    "    print('¡Enhorabuena, estás jubilado!')\n",
    "else:\n",
    "    print('Deberías estar trabajando, si te dejan.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Por último, podemos evaluar distintas condiciones con instrucciones del tipo `if-elif-else`, con la siguiente sintaxis:\n",
    "\n",
    "    if COMPARACIÓN1:\n",
    "        # si la comparación es True, ejecuta lo siguiente\n",
    "        INSTRUCCIONES_1\n",
    "    elif COMPARACIÓN2:\n",
    "        # si esta comparación es True, ejecuta lo siguiente\n",
    "        INSTRUCCIONES_2\n",
    "    else:\n",
    "        # por el contrario, si ninguna comparación es True, ejecuta\n",
    "        INSTRUCCIONES_3\n",
    "\n",
    "Piensa en `elif` como en una abreviatura de `else + if`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "¡Ya es primavera!\n"
     ]
    }
   ],
   "source": [
    "# prueba cambiando el valor asignado a la variable edad\n",
    "temperatura = 22\n",
    "\n",
    "if temperatura <= 0: \n",
    "    print('¡Está helando!')\n",
    "elif 1 <= temperatura <= 10:\n",
    "    print('¡Hace frescuni!')\n",
    "elif 11 <= temperatura <= 25:\n",
    "    print('¡Ya es primavera!')\n",
    "else:\n",
    "    print('¡Buff, qué calor!')   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Operadores lógicos (o booleanos)\n",
    "\n",
    "Los operadores lógicos son palabras usadas para conectar *oraciones* de Python de forma gramaticalmente correcta, casi igual que si lo hiciésamos en lenguaje natural. Existen tres operadores lógicos:\n",
    "\n",
    "- la conjunción `and`: \n",
    "- la disyunción `or`.\n",
    "- la negación `not`.\n",
    "\n",
    "Al igual que con las comparaciones, los operadores lógicos generan valores booleanos: `True` o `False`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Te pareces a mí en algo.\n"
     ]
    }
   ],
   "source": [
    "nombre = 'Pepe'\n",
    "edad = 37\n",
    "\n",
    "if nombre == 'Víctor' and edad == 37:\n",
    "    print('¡Hey! ¡Eres yo! ¿Quién te envía?')\n",
    "elif nombre == 'Víctor' or edad == 37:\n",
    "    print('Te pareces a mí en algo.')\n",
    "if not nombre == 'Víctor' and not edad == 37: # esto es equivalente a if nombre != \"Víctor\" and edad != 34:\n",
    "    print('No tienes nada que ver conmigo')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Pepito', 'Raul', 'Ana', 'Antonio', 'Maria']\n"
     ]
    }
   ],
   "source": [
    "alumnos = 'Pepito:Raul:Ana:Antonio:Maria'.split(':')\n",
    "print(alumnos)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No es cierto que Paco y Ana estén en clase\n"
     ]
    }
   ],
   "source": [
    "if 'Paco' in alumnos and 'Ana' in alumnos:\n",
    "    print('Paco y Ana están en clase.')\n",
    "else:\n",
    "    print('No es cierto que Paco y Ana estén en clase')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Paco o Ana, uno de los dos o ambos, está en clase.\n"
     ]
    }
   ],
   "source": [
    "if \"Paco\" in alumnos or \"Ana\" in alumnos:\n",
    "    print('Paco o Ana, uno de los dos o ambos, está en clase.')\n",
    "else:\n",
    "    print('No ha venido ninguno')"
   ]
  }
 ],
 "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.4.3+"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}