02_Flujo_de_Programas.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib\n",
    "import seaborn as sns\n",
    "matplotlib.rcParams['savefig.dpi'] = 144"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import expectexception"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Flujo de programa\n",
    "<!-- requirement: images/high_score_flowchart.png -->\n",
    "<!-- requirement: images/nested_logic_flowchart.png -->"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ¿Qué es un programa de computadora?\n",
    "\n",
    "En su forma más simple, un programa es una lista de instrucciones que una computadora lleva a cabo en orden. Un programa puede ser largo y complicado, pero está hecho de partes simples. Veamos algunas operaciones simples en Python y pensemos qué hace la computadora con cada una de ellas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7.0"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 * 3.5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7.0"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 + 1\n",
    "2 * 3.5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En la primera celda calculamos `1 + 1`, y Python devuelve el resultado` 2`. Podemos pensar en esto como un programa muy corto. De manera similar, en la segunda celda calculamos `2 * 3.5`, y Python devuelve el resultado` 7.0`.\n",
    "\n",
    "Sin embargo, en la tercera celda, cuando combinamos estas dos afirmaciones como líneas secuenciales, solo vemos el retorno de Python `7.0`. ¿Porqué es eso?\n",
    "\n",
    "Python solo puede devolver un resultado al final de la celda, por lo que se evalúa la primera línea, pero nunca vemos el resultado. Una forma en que podemos reportar resultados intermedios es usando `print`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "7.0\n"
     ]
    }
   ],
   "source": [
    "print(1 + 1)\n",
    "print(2 * 3.5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "También podemos incluir líneas en el código que la computadora no ejecutará. Llamamos a estas líneas **comentarios**, porque se usan para agregar notas y explicaciones al código. Usamos `#` para indicar que estamos haciendo un comentario."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('1 + 1 is', 2)\n",
      "All done!\n"
     ]
    }
   ],
   "source": [
    "print(('1 + 1 is', 1 + 1))\n",
    "# this is a comment, Python won't try to execute it\n",
    "print('All done!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A menudo no solo queremos imprimir resultados intermedios, sino almacenarlos para su uso posterior. Podemos almacenar un resultado en la memoria de la computadora asignándolo a una **variable**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7.0\n"
     ]
    }
   ],
   "source": [
    "first_result = 1 + 1\n",
    "final_result = first_result * 3.5\n",
    "\n",
    "print(final_result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Aquí pudimos usar el resultado del primer cálculo (almacenado en la variable `first_result`) en nuestro segundo cálculo. Almacenamos el segundo resultado en `final_result`, que podemos imprimir al final de la celda.\n",
    "\n",
    "Las variables nos ayudan a mantener un registro de la información que necesitamos para ejecutar un programa con éxito. Las variables se pueden utilizar para almacenar una variedad de tipos de información."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('My name is', 'Dylan')\n",
      "('My age is', 27)\n",
      "('My favorite number is', 2.718)\n",
      "('I own a dog:', True)\n"
     ]
    }
   ],
   "source": [
    "my_name = 'Dylan'\n",
    "my_age = 27\n",
    "my_favorite_number = 2.718\n",
    "has_dog = True\n",
    "\n",
    "print(('My name is', my_name))\n",
    "print(('My age is', my_age))\n",
    "print(('My favorite number is', my_favorite_number))\n",
    "print(('I own a dog:', has_dog))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dado que las variables se pueden usar para almacenar tantos tipos de información, es una buena idea darles nombres descriptivos a esas variables como lo hice yo. Esto nos ayuda a escribir código que es fácil de leer, lo que nos ayuda cuando intentamos encontrar y corregir errores, o compartir código con otros."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'str'>\n",
      "<class 'int'>\n",
      "<class 'float'>\n",
      "<class 'bool'>\n"
     ]
    }
   ],
   "source": [
    "print((type(my_name)))\n",
    "print((type(my_age)))\n",
    "print((type(my_favorite_number)))\n",
    "print((type(has_dog)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**string** es una secuencia de caracteres. Un **integer** tiene el mismo significado que en matemáticas (es decir, \"números enteros\"). Un **float** o un número de punto flotante se refiere a un número decimal (es decir, \"número real\" en matemáticas); se llama flotante porque se permite que el punto decimal \"flote\" a través de los dígitos, lo que nos permite representar tanto los números grandes (por ejemplo, 204939.12) como los números pequeños (por ejemplo, 0.000239). **bool** o **boolean** se refiere a una variable que es verdadera o falsa.\n",
    "\n",
    "Estos son solo algunos tipos de datos que encontraremos y exploraremos otros más adelante en el curso.\n",
    "\n",
    "En Python, podemos asignar cualquier tipo de datos a una variable sin declarar qué tipo será la variable por adelantado. No todos los lenguajes de programación se comportan de esta manera."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ejercicios\n",
    "\n",
    "1. Defina una variable `my_name` con un valor correspondiente a su propio nombre e imprímala."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ruben\n"
     ]
    }
   ],
   "source": [
    "my_name='Ruben'\n",
    "print(my_name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Funciones\n",
    "\n",
    "Muchos programas reaccionan a la entrada del usuario. Las funciones nos permiten definir una tarea que nos gustaría que la computadora realice en función de la entrada. Una función simple en Python podría verse así:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def square(number):\n",
    "    return number**2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Definimos funciones usando la palabra clave `def`. Luego viene el nombre de la función, que en este caso es `square`. Luego, encerramos la entrada de la función entre paréntesis, en este caso `número`. Usamos `:` para decirle a Python que estamos listos para escribir el cuerpo de la función.\n",
    "\n",
    "En este caso el cuerpo de la función es muy simple; devolvemos el cuadrado de `número` (usamos`**`para exponentes en Python). La palabra clave `return` indica que la función generará alguna salida. No todas las funciones tendrán una declaración de `retorno`, pero muchas tendrán. Una declaración de 'retorno' termina una función.\n",
    "\n",
    "Veamos nuestra función en acción:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "30.25\n",
      "36\n"
     ]
    }
   ],
   "source": [
    "# we can store function output in variables\n",
    "squared = square(5.5)\n",
    "\n",
    "print(squared)\n",
    "\n",
    "my_number = 6\n",
    "# we can also use variables as function input\n",
    "print((square(my_number)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos pasar diferentes entradas a la función `square`, incluidas las variables. Cuando pasamos un flotador a `square`, devolvió un flotador. Cuando pasamos un entero, `square` devolvió un entero. En ambos casos, la entrada fue interpretada por la función como el argumento `número`.\n",
    "\n",
    "No todas las entradas posibles son válidas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m\n",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)\n",
      "\u001b[0;32m<ipython-input-15-ae2e519c2d8c>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n",
      "\u001b[0;32m----> 1\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msquare\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'banana'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0m\n",
      "\u001b[0;32m<ipython-input-13-14ad5632da12>\u001b[0m in \u001b[0;36msquare\u001b[0;34m(number)\u001b[0m\n",
      "\u001b[1;32m      1\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0msquare\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnumber\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m----> 2\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0mnumber\u001b[0m\u001b[0;34m**\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0m\n",
      "\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for ** or pow(): 'str' and 'int'\n"
     ]
    }
   ],
   "source": [
    "%%expect_exception TypeError\n",
    "\n",
    "print(square('banana'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nos encontramos con un error porque `'banana'` es una cadena, no un número. Debemos tener cuidado de asegurarnos de que la entrada para una función tenga sentido para el propósito de esa función. Hablaremos más sobre errores como este más adelante.\n",
    "\n",
    "### Ejercicios\n",
    "\n",
    "1. Escribe una función para calcular un número.\n",
    "2. Escriba una función, `say_hello` que toma una variable de nombre e imprima\" Hola nombre \". `say_hello (\"zach\")` debería imprimir `\"Hola zach\"`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    }
   ],
   "source": [
    "def doblar_numero(n):\n",
    "    return 2*n\n",
    "\n",
    "print(doblar_numero(2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hola  Christian\n"
     ]
    }
   ],
   "source": [
    "def say_hello(name):\n",
    "    print ('Hola ', name)\n",
    "    \n",
    "say_hello(\"Christian\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ¿Por qué funciona?\n",
    "Podemos ver que las funciones son útiles para manejar las opiniones de los usuarios, pero también son útiles en muchos otros casos. Un ejemplo es cuando queremos realizar una acción varias veces en diferentes entradas. Si quiero cuadrar un montón de números, en particular los números entre 1 y 10, puedo hacer esto con bastante facilidad (más adelante aprenderemos sobre la iteración, ¡lo hará aún más fácil!)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "81"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1**2\n",
    "2**2\n",
    "3**2\n",
    "4**2\n",
    "5**2\n",
    "6**2\n",
    "7**2\n",
    "8**2\n",
    "9**2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Parece que olvidé guardar las respuestas o al menos imprimirlas. Esto es facil:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "4\n",
      "9\n",
      "16\n",
      "25\n",
      "36\n",
      "49\n",
      "64\n",
      "81\n"
     ]
    }
   ],
   "source": [
    "print((1**2))\n",
    "print((2**2))\n",
    "print((3**2))\n",
    "print((4**2))\n",
    "print((5**2))\n",
    "print((6**2))\n",
    "print((7**2))\n",
    "print((8**2))\n",
    "print((9**2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "¡Eso funciono! Sin embargo, ¿qué pasa si ahora quiero volver y agregar dos a todas las respuestas? Claramente, cambiar cada instancia no es la forma correcta de hacerlo. En su lugar, definamos una función para hacer el trabajo por nosotros."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "#def do_it(x):\n",
    "#    print((x**2 + 2))\n",
    "    \n",
    "    \n",
    "def do_it(x):\n",
    "    print(x**2)    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ahora podemos simplemente llamar a la función en cada elemento. Si queremos cambiar la salida, solo necesitamos cambiar la función en un solo lugar, ¡no en todos los lugares que queremos usar!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "4\n",
      "9\n",
      "16\n",
      "25\n",
      "36\n",
      "49\n",
      "64\n",
      "81\n"
     ]
    }
   ],
   "source": [
    "do_it(1)\n",
    "do_it(2)\n",
    "do_it(3)\n",
    "do_it(4)\n",
    "do_it(5)\n",
    "do_it(6)\n",
    "do_it(7)\n",
    "do_it(8)\n",
    "do_it(9)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La división del trabajo en funciones es a menudo una forma de hacer que el código sea más modular y comprensible. También ayuda a asegurar que su código sea correcto. Si escribimos una función y la probamos para que sea correcta, sabemos que será correcta cada vez que la usemos. Si no dividimos el código en una función, es muy fácil hacer errores tipográficos u otros errores que harán que nuestros programas se rompan.\n",
    "\n",
    "### Ejercicios\n",
    "\n",
    "1. Modifique la función `do_it` para imprimir el cuadrado del valor que actualmente imprime."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sintaxis\n",
    "\n",
    "A medida que nuestras instrucciones para la computadora se vuelven más complicadas, tendremos que organizarlas de una manera que la computadora entienda. Ya hemos visto un ejemplo de esto con nuestra función `square`. Había un orden específico para las palabras y los símbolos específicos que teníamos que usar para que Python supiera qué parte de la función era la definición y qué parte era el cuerpo, o qué parte era el nombre de la función y qué parte era el argumento. Llamamos a las reglas para organizar el código la sintaxis del lenguaje de programación.\n",
    "\n",
    "La sintaxis de Python está muy optimizada para que el código sea legible e intuitivo. Python logra esto usando espacios en blanco para organizar el código. Veamos algunos ejemplos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "example_a is running\n",
      "returning value \"a\"\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'a'"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def example_a():\n",
    "    print('example_a is running')\n",
    "    print('returning value \"a\"')\n",
    "    return 'a'\n",
    "\n",
    "example_a()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "example_b is running\n",
      "exiting without returning a value\n"
     ]
    }
   ],
   "source": [
    "def example_b():\n",
    "    print('example_b is running')\n",
    "    print('exiting without returning a value')\n",
    "\n",
    "example_b()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La función `example_a` termina con una declaración de retorno, pero` example_b` no tiene una declaración de retorno. ¿Cómo sabe Python dónde termina `example_b`? Usamos la sangría para indicar qué líneas son parte de la función y cuáles no. Las líneas con sangría se agrupan todas juntas en la definición de la función. Veremos este formato nuevamente para controlar si ciertas secciones del código se ejecutan."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Condicionales y lógica.\n",
    "\n",
    "A menudo queremos que la computadora solo realice una acción en ciertas circunstancias. Por ejemplo, podríamos querer que un juego imprima el mensaje \"¡Puntaje alto!\", Pero solo si el puntaje del jugador es más alto que el puntaje anterior. Podemos escribir esto como una declaración lógica formal: si el puntaje del jugador es más alto que el puntaje anterior anterior, entonces imprima \"¡Puntaje alto!\".\n",
    "\n",
    "La sintaxis para expresar esta lógica en Python es muy similar. Definamos una función que acepte la puntuación del jugador y la puntuación más alta anterior como argumentos. Si el puntaje del jugador es más alto, se imprimirá '¡Puntaje alto!'. Finalmente, devolverá el nuevo puntaje alto (el que sea)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "def test_high_score(player_score, high_score):\n",
    "    if player_score > high_score:\n",
    "        print('High score!')\n",
    "        high_score = player_score\n",
    "\n",
    "    return high_score"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "98\n"
     ]
    }
   ],
   "source": [
    "print(test_high_score(83, 98))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "High score!\n",
      "95\n"
     ]
    }
   ],
   "source": [
    "print(test_high_score(95, 93))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Con las declaraciones `if` usamos una sintaxis similar a la que usamos para organizar funciones. Con las funciones teníamos una instrucción `def` que terminaba con`: `, y un cuerpo con sangría. De manera similar, para un condicional, tenemos una instrucción `if` que termina con`: `y un cuerpo con sangría.\n",
    "\n",
    "Las declaraciones condicionales se utilizan para controlar el flujo del programa. Podemos visualizar nuestro ejemplo, `test_high_score`, en un árbol de decisión.\n",
    "\n",
    "![simple_logic_flowchart](images/high_score_flowchart.png)\n",
    "\n",
    "Podemos anidar declaraciones 'if' para hacer árboles más complicados."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "branch a\n",
      "branch c\n",
      "branch b\n"
     ]
    }
   ],
   "source": [
    "def nested_example(x):\n",
    "    if x < 50:\n",
    "        if x % 2 == 0:\n",
    "            return 'branch a'\n",
    "        else:\n",
    "            return 'branch b'\n",
    "    else:\n",
    "        return 'branch c'\n",
    "\n",
    "print((nested_example(42)))\n",
    "print((nested_example(51)))\n",
    "print((nested_example(37)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En este ejemplo, tenemos una instrucción `if` anidada bajo otra instrucción` if`. A medida que cambiamos la entrada, terminamos en diferentes ramas del árbol.\n",
    "\n",
    "![nested_logic_flowchart](images/nested_logic_flowchart.png)\n",
    "\n",
    "La declaración que sigue al `if` se llama **condición**. La condición puede ser verdadera o falsa. Si la condición es verdadera, entonces ejecutamos las declaraciones debajo de `if`. Si la condición es falsa, entonces ejecutamos las declaraciones debajo de `else` (o si no hay` else`, entonces no hacemos nada).\n",
    "\n",
    "Las condiciones mismas son instrucciones que Python puede interpretar."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "print(50 > 10)\n",
    "print(2 + 2 == 4)\n",
    "print(-3 > 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Las condiciones se evalúan como booleanos, que son `True` o` False`. Podemos combinar las condiciones solicitando que la condición A y la condición B sean verdaderas. También podríamos preguntar si la condición A o la condición B son verdaderas. Consideremos si tales afirmaciones son verdaderas en general basadas en los posibles valores de la condición A y la condición B.\n",
    "\n",
    "| Condición A | Condición B | Condición A and Condición B | Condición A or Condición B |\n",
    "|:---------:|:---------:|:-------------------------:|:------------------------:|\n",
    "|True|True|True|True|\n",
    "|True|False|False|True|\n",
    "|False|True|False|True|\n",
    "|False|False|False|False|"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "False\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "print((True and True))\n",
    "print((True and False))\n",
    "print((False and True))\n",
    "print((False and False))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "print((True or True))\n",
    "print((True or False))\n",
    "print((False or True))\n",
    "print((False or False))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "x = 5\n",
    "y = 3\n",
    "\n",
    "print((x > 4 and y > 2))\n",
    "print((x > 7 and y > 2))\n",
    "print((x > 7 or y > 2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Las palabras clave `o` y` y` se denominan **operaciones lógicas** (en el mismo sentido que llamamos `+`, `-`,` * `, etc. operaciones aritméticas). La última operación lógica es `not`:` not True` es `False`,` not False` es `True`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print((not True))\n",
    "print((not False))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "x = 10\n",
    "y = 8\n",
    "\n",
    "print((x > 7 or y < 7))\n",
    "print((not x > 7 or y < 7))\n",
    "print((not x > 7 or not y < 7))\n",
    "print((not (x > 7 or y < 7)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ejercicios\n",
    "\n",
    "1. Escriba una función que tome un número y devuelva Verdadero si es mayor que 10 pero menor que 20 o menor que -100.\n",
    "2. En el código anterior hemos utilizado el operador `%`. ¿Qué hace esto?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "def f(n):\n",
    "    if( n>10 and n<20 or n<-100 ): \n",
    "        return True\n",
    "    else:\n",
    "        return False\n",
    "    \n",
    "print(f(1))\n",
    "\n",
    "print(f(16))\n",
    "\n",
    "print(f(-101))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Iteración\n",
    "\n",
    "Los condicionales son muy útiles porque permiten que nuestros programas tomen decisiones basadas en cierta información. Estas decisiones controlan el flujo del programa (es decir, qué instrucciones se ejecutan). Tenemos otra herramienta importante para controlar el flujo del programa, que es la repetición. En programación, usaremos bucles repetitivos para ejecutar el mismo código muchas veces. Esto se llama **iteración**. El tipo más básico de iteración es el bucle 'while'. Un bucle `while` seguirá ejecutándose mientras la condición después de` while` sea `True`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "x = 0\n",
    "while x < 5:\n",
    "    print(x)\n",
    "    x = x + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A menudo usaremos la iteración para realizar una tarea un cierto número de veces, pero también podremos usarla para llevar a cabo un proceso hasta una cierta etapa de finalización.\n",
    "\n",
    "Como ejemplo de estos diferentes casos, consideraremos la secuencia de Fibonacci. La secuencia de Fibonacci es una secuencia de números donde el siguiente número en la secuencia está dado por la suma de los dos números anteriores. Los primeros dos números se dan como 0 y 1. Así que la secuencia comienza 0, 1, 1, 2, 3, 5, 8 ...\n",
    "\n",
    "La secuencia de Fibonacci continúa infinitamente, por lo que solo podemos calcular parte de ella. A continuación definimos dos funciones para calcular parte de la secuencia de Fibonacci; la primera función calcula los primeros términos `n`, mientras que la segunda función calcula todos los términos menos que un límite superior,` x`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "def first_n_fibonacci(n):\n",
    "    prev_num = 0\n",
    "    curr_num = 1\n",
    "    count = 2\n",
    "\n",
    "    print(prev_num)\n",
    "    print(curr_num)\n",
    "\n",
    "    while count <= n:\n",
    "        next_num = curr_num + prev_num\n",
    "        print(next_num)\n",
    "        prev_num = curr_num\n",
    "        curr_num = next_num\n",
    "        count += 1\n",
    "\n",
    "def below_x_fibonacci(x):\n",
    "    prev_num = 0\n",
    "    curr_num = 1\n",
    "\n",
    "    if curr_num < x:\n",
    "        print(prev_num)\n",
    "        print(curr_num)\n",
    "    elif prev_num < x:\n",
    "        print(prev_num)\n",
    "    \n",
    "    while curr_num + prev_num < x:\n",
    "        next_num = curr_num + prev_num\n",
    "        print(next_num)\n",
    "        prev_num = curr_num\n",
    "        curr_num = next_num"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "First 7 Fibonacci numbers\n",
      "0\n",
      "1\n",
      "1\n",
      "2\n",
      "3\n",
      "5\n",
      "8\n",
      "13\n"
     ]
    }
   ],
   "source": [
    "m = 7\n",
    "print(('First %d Fibonacci numbers' % m))\n",
    "first_n_fibonacci(m)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Fibonacci numbers below 40\n",
      "0\n",
      "1\n",
      "1\n",
      "2\n",
      "3\n",
      "5\n",
      "8\n",
      "13\n",
      "21\n",
      "34\n"
     ]
    }
   ],
   "source": [
    "print()\n",
    "\n",
    "y = 40\n",
    "print(('Fibonacci numbers below %d' % y))\n",
    "below_x_fibonacci(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A veces queremos que nuestro programa realice una acción repetida, pero no sabremos cuántas repeticiones tendremos que hacer, o podría ser difícil saber con anticipación cuándo debe detenerse el programa. Por ejemplo, podríamos escribir un programa que imprima las instrucciones de cocción. No sabemos de antemano cuántas instrucciones habrá en la receta (algunas comidas tardan mucho tiempo en cocinarse y tienen muchos pasos, mientras que otras son cortas y fáciles de hacer). Tampoco sabemos cuál podría ser la última instrucción, por lo que sería difícil escribir un condicional que indique al programa cuándo debe detenerse. ¿Cómo vamos a resolver el problema? Veamos un ejemplo.\n",
    "  \n",
    "Instrucciones para hacer pan:  \n",
    "1) Disolver la sal en agua.  \n",
    "2) Mezclar la levadura en agua  \n",
    "3) Mezclar agua con harina para formar masa.  \n",
    "4) amasar la masa  \n",
    "5) Deje que la masa suba  \n",
    "6) Forma la masa  \n",
    "7) Hornear  \n",
    "  \n",
    "La receta tiene una lista ordenada de instrucciones. En Python podemos usar una lista de cadenas para representar las instrucciones."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "bread_recipe = ['Dissolve salt in water',\n",
    "                'Mix yeast into water',\n",
    "                'Mix water with flour to form dough', \n",
    "                'Knead dough', \n",
    "                'Let dough rise',\n",
    "                'Shape dough', \n",
    "                'Bake']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Discutiremos las listas más en [Estructuras de Datos](03_Estructuras_de_Datos.ipynb). Podríamos almacenar diferentes recetas en diferentes listas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "soup_recipe = ['Dissolve salt in water',\n",
    "               'Boil  water',\n",
    "               'Add bones to boiling water',\n",
    "               'Chop onions', \n",
    "               'Chop garlic',\n",
    "               'Chop carrot',\n",
    "               'Chop celery',\n",
    "               'Remove bones from water', \n",
    "               'Add vegetables to boiling water',\n",
    "               'Add meat to boiling water']\n",
    "\n",
    "beans_recipe = ['Soak beans in water',\n",
    "                'Dissolve salt in water',\n",
    "                'Heat water and beans to boil', \n",
    "                'Drain beans when done cooking']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cada una de estas listas tiene instrucciones diferentes y no todas tienen la misma longitud. La receta de frijoles tiene cuatro pasos, mientras que la receta de sopa tiene diez. Sería difícil escribir un bucle `while` para imprimir cada paso. Es mucho más fácil hacerlo usando un bucle `for`.\n",
    "\n",
    "Un bucle `for` realiza una acción para cada elemento en una` lista` (o más precisamente, en **iterable**)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_recipe(instructions):\n",
    "    for step in instructions:\n",
    "        print(step)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dissolve salt in water\n",
      "Boil  water\n",
      "Add bones to boiling water\n",
      "Chop onions\n",
      "Chop garlic\n",
      "Chop carrot\n",
      "Chop celery\n",
      "Remove bones from water\n",
      "Add vegetables to boiling water\n",
      "Add meat to boiling water\n"
     ]
    }
   ],
   "source": [
    "print_recipe(soup_recipe)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dissolve salt in water\n",
      "Mix yeast into water\n",
      "Mix water with flour to form dough\n",
      "Knead dough\n",
      "Let dough rise\n",
      "Shape dough\n",
      "Bake\n"
     ]
    }
   ],
   "source": [
    "print_recipe(bread_recipe)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Soak beans in water\n",
      "Dissolve salt in water\n",
      "Heat water and beans to boil\n",
      "Drain beans when done cooking\n"
     ]
    }
   ],
   "source": [
    "print_recipe(beans_recipe)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "También podemos usar un bucle `for` para repetir una tarea un cierto número de veces, como imprimir los primeros números` n` en la secuencia de Fibonacci. Compara estas dos funciones de Fibonacci:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "def first_n_fibonacci_while(n):\n",
    "    prev_num = 0\n",
    "    curr_num = 1\n",
    "    count = 2\n",
    "\n",
    "    print(prev_num)\n",
    "    print(curr_num)\n",
    "\n",
    "    while count <= n:\n",
    "        next_num = curr_num + prev_num\n",
    "        print(next_num)\n",
    "        prev_num = curr_num\n",
    "        curr_num = next_num\n",
    "        count += 1\n",
    "\n",
    "def first_n_fibonacci_for(n):\n",
    "    prev_num = 0\n",
    "    curr_num = 1\n",
    "\n",
    "    print(prev_num)\n",
    "    print(curr_num)\n",
    "\n",
    "    for count in range(2, n + 1):\n",
    "        next_num = curr_num + prev_num\n",
    "        print(next_num)\n",
    "        prev_num = curr_num\n",
    "        curr_num = next_num"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "1\n",
      "2\n",
      "3\n",
      "5\n",
      "8\n",
      "13\n"
     ]
    }
   ],
   "source": [
    "first_n_fibonacci_while(7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "1\n",
      "2\n",
      "3\n",
      "5\n",
      "8\n",
      "13\n"
     ]
    }
   ],
   "source": [
    "first_n_fibonacci_for(7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ejercicios\n",
    "\n",
    "1. Compara `first_n_fibonacci_while` y` first_n_fibonacci_for`, ¿cuál es \"mejor\"?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Recursion\n",
    "\n",
    "Otra forma de obtener algo como la iteración se llama _recursión_ que es cuando definimos una función en términos de sí misma. Vamos a escribir la secuencia de Fibonacci de forma recursiva. Esto será ligeramente diferente, ya que solo calculará el número n de Fibonacci."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fibonacci_recursive(n):\n",
    "    if n == 0:\n",
    "        return 0\n",
    "    elif n == 1:\n",
    "        return 1\n",
    "    else:\n",
    "        return fibonacci_recursive(n-1)  + fibonacci_recursive(n-2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "13"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fibonacci_recursive(7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Aquí utilizamos el hecho de que un número de Fibonacci $F_n$ se puede definir en términos de $F_{N-1}$ y $F_{N-2}$ con algunos casos básicos $F_0 = 0$ y $F_1 = 1$. No utilizaremos la recursión en este curso, pero es una construcción de programación interesante y útil."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Poniendolo todo junto\n",
    "\n",
    "Hemos aprendido dos de los componentes principales de los programas: **variables** y **funciones**. También hemos aprendido dos de los componentes principales del control del programa: **condicionales** ('if') y **iteración** (bucles `for` y` while`). Podemos usar estas ideas y herramientas para escribir código para realizar tareas complejas. Veamos un ejemplo, involucrando todas estas ideas juntas.\n",
    "\n",
    "A continuación escribimos una función que imprime todos los números primos hasta algún número `n`. Usaremos la iteración para verificar si cada número es primo. Usaremos un condicional para imprimir números solo si son primos. También dividiremos la tarea en partes pequeñas para que nuestro código sea fácil de leer y entender. Esto significa que usaremos (o _call_) funciones de ayuda dentro de nuestra solución."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "def is_prime(number):\n",
    "    if number == 1:\n",
    "        return False\n",
    "    \n",
    "    for factor in range(2, number):\n",
    "        if number % factor == 0:\n",
    "            return False\n",
    "\n",
    "    return True\n",
    "\n",
    "def print_primes(n):\n",
    "    for number in range(1, n):\n",
    "        if is_prime(number):\n",
    "            print(('%d is prime' % number))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 is prime\n",
      "3 is prime\n",
      "5 is prime\n",
      "7 is prime\n",
      "11 is prime\n",
      "13 is prime\n",
      "17 is prime\n",
      "19 is prime\n",
      "23 is prime\n",
      "29 is prime\n",
      "31 is prime\n",
      "37 is prime\n",
      "41 is prime\n",
      "43 is prime\n",
      "47 is prime\n"
     ]
    }
   ],
   "source": [
    "print_primes(50)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La otra aplicación de funciones podría ser hacer algo muchas veces (no necesariamente en una iteración). Una forma específica y natural de entender esto es tener una lista de elementos y aplicar una función a cada elemento de la \"lista\". Vamos a tomar una lista de los primeros 20 números y encontrar cuáles son primos. Haremos esto y guardaremos el resultado en una `lista`. Las listas tienen un método `append` que nos permite agregar al final de la lista (veremos más sobre las listas en la próxima conferencia)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[True,\n",
       " False,\n",
       " True,\n",
       " True,\n",
       " False,\n",
       " True,\n",
       " False,\n",
       " True,\n",
       " False,\n",
       " False,\n",
       " False,\n",
       " True,\n",
       " False,\n",
       " True,\n",
       " False,\n",
       " False,\n",
       " False,\n",
       " True,\n",
       " False,\n",
       " True]"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list_of_numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]\n",
    "prime_list = []\n",
    "for number in list_of_numbers:\n",
    "    prime_list.append(is_prime(number))\n",
    "prime_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python proporciona una construcción agradable para aplicar una función a cada elemento de una lista, llamada \"comprensión de lista\", aquí hay un ejemplo de uno:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[True,\n",
       " False,\n",
       " True,\n",
       " True,\n",
       " False,\n",
       " True,\n",
       " False,\n",
       " True,\n",
       " False,\n",
       " False,\n",
       " False,\n",
       " True,\n",
       " False,\n",
       " True,\n",
       " False,\n",
       " False,\n",
       " False,\n",
       " True,\n",
       " False,\n",
       " True]"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[is_prime(number) for number in list_of_numbers]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tenga en cuenta que esto es un simple código de código que es muy comprensible. No necesitamos preocuparnos **cómo** está ocurriendo el cálculo `is_prime`, solo que está ocurriendo para cada elemento de` list_of_numbers`. Esto significa que podemos ver más nuestro programa a un alto nivel sin preocuparnos por los pequeños detalles (que esperamos que ya hayamos diseñado bien y probado)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Más sobre las funciones\n",
    "\n",
    "Observe que `example_a` y` example_b` no tuvieron entrada, pero otras funciones como `test_high_score` tuvieron múltiples variables como entrada. Recuerde que un argumento de función es solo un marcador de posición para un nombre y estará vinculado a cualquier cosa que se pase a la función. Por ejemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "inside print_this:  2\n",
      "a =  5\n"
     ]
    }
   ],
   "source": [
    "def print_this(a):\n",
    "    print('inside print_this: ', a)\n",
    "\n",
    "a = 5\n",
    "print_this(2)\n",
    "print('a = ', a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tenga en cuenta que aunque `print_this` estaba imprimiendo la variable` a` dentro de la función y había una variable `a` definida fuera de la función, la función` print` dentro de `print_this` aún imprimía lo que se había pasado. Sin embargo, se puede también:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('inside print_it: ', 5)\n",
      "('a = ', 5)\n"
     ]
    }
   ],
   "source": [
    "def print_it():\n",
    "    print(('inside print_it: ', a))\n",
    "    \n",
    "a = 5\n",
    "print_it()\n",
    "print(('a = ', a))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Aquí no se pasa una variable a la función, por lo que Python usa la variable desde el ámbito externo. Ten cuidado con este segundo paradigma ya que puede ser peligroso. El peligro radica en el hecho de que la salida de la función depende del estado general del programa (es decir, el valor de `a`) en oposición a` print_this` que depende solo de la entrada de la función. Las funciones como `print_this` son mucho más fáciles de razonar, probar y usar, deberían ser preferidas en muchos contextos.\n",
    "\n",
    "Dicho esto, existe una técnica muy poderosa llamada `function closure` que podemos utilizar esta habilidad. Digamos que queremos una función que aumente el número a algún exponente, pero no sabemos qué exponente antes del tiempo de ejecución. Podemos definir una función como esta."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "def some_exponent(exponent):\n",
    "    def func(x):\n",
    "        return x**exponent\n",
    "    return func"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(4, 8)"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "some_exponent(2)(2), some_exponent(3)(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ahora que entendemos cómo funcionan los argumentos normales, veamos algunas conveniencias que proporciona Python para facilitar la creación de funciones. El primero es argumentos por defecto. Supongamos que tenemos una función que tiene un montón de argumentos, pero la mayoría de ellos tienen valores predeterminados, por ejemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I need to:\n",
      "  watch_tv\n",
      "  eat\n",
      "  sleep\n"
     ]
    }
   ],
   "source": [
    "def print_todo(watch_tv, read, eat, sleep):\n",
    "    print('I need to:')\n",
    "    if watch_tv:\n",
    "        print('  watch_tv')\n",
    "    if read:\n",
    "        print('  read')\n",
    "    if eat:\n",
    "        print('  eat')\n",
    "    if sleep:\n",
    "        print('  sleep')\n",
    "print_todo(True, False, True, True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sé que casi siempre necesito comer y dormir, así que puedo usar un argumento predeterminado para estos. Esto significa que no necesito definir el valor de `eat` y` sleep` a menos que sean diferentes a los predeterminados."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I need to:\n",
      "  sleep\n"
     ]
    }
   ],
   "source": [
    "def print_todo_default(watch_tv, read, eat=True, sleep=True):\n",
    "    print('I need to:')\n",
    "    if watch_tv:\n",
    "        print('  watch_tv')\n",
    "    if read:\n",
    "        print('  read')\n",
    "    if eat:\n",
    "        print('  eat')\n",
    "    if sleep:\n",
    "        print('  sleep')\n",
    "print_todo_default(False, False, False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Estos argumentos predeterminados pueden permitirnos crear una función compleja con muchas entradas y, al mismo tiempo, mantener la facilidad de uso al establecer valores predeterminados sanos.\n",
    "\n",
    "Otra cosa que podríamos querer hacer es tomar una lista variable de argumentos, escribamos una función similar de \"todo\" como antes, pero esta vez le permitiremos pasar cualquier número de argumentos. Aquí haremos uso de la sintaxis `*args`. Este `*` le dice a python que reúna el resto de los argumentos en la tupla `args`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I need to:\n",
      "  read\n",
      "  eat\n",
      "  sleep\n"
     ]
    }
   ],
   "source": [
    "def print_todo_args(*args):\n",
    "    print('I need to:')\n",
    "    for arg in args:\n",
    "        print(('  ' + arg))\n",
    "#print_todo_args('watch_tv', 'read', 'eat', 'sleep')\n",
    "print_todo_args('read', 'eat', 'sleep')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Este tipo de sintaxis puede ser muy útil en grandes programas donde las funciones abstractas pueden tener una variedad de funciones diferentes con diferentes argumentos."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Algunos temas que no hemos discutido, pero que hemos usado:\n",
    "- [String formatting](https://pyformat.info/)\n",
    "- Exceptions (e.g. `TypeError`)"
   ]
  }
 ],
 "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.4"
  },
  "nbclean": true,
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "oldHeight": 577.85,
   "position": {
    "height": "599.85px",
    "left": "1024px",
    "right": "20px",
    "top": "120px",
    "width": "329px"
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "varInspector_section_display": "block",
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}