06_loops_if_functions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"media/coco-banner.jpg\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "# More Python | Más de Python\n",
    "\n",
    "In this notebook we will learn about: \n",
    "* For loops | Iteraciones o \"for loops\"\n",
    "* Conditional statements | Declaraciones condicionales\n",
    "* Write our own functions | Escribir nuestras propias funciones"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## For loops\n",
    "\n",
    "Let's assume we have a list of odd numbers `[1, 3, 5, 7, 9]` and we want to print each one of them on their own line.\n",
    "A possible way to do so might be:\n",
    "\n",
    "---\n",
    "\n",
    "Supongamos que tenemos una lista de números impares `[1, 3, 5, 7, 9]` y deseamos imprimir cada unos de esos números en una línea.\n",
    "Una forma de realizarlo podría ser:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "3\n",
      "5\n",
      "7\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "impares = [1, 3, 5, 7, 9]\n",
    "\n",
    "print(impares[0])\n",
    "print(impares[1])\n",
    "print(impares[2])\n",
    "print(impares[3])\n",
    "print(impares[4])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, this method is very tedious and is not scalable: if we have a list of 1000 elements, we would need to write 1000 lines of code to achieve our goal.\n",
    "\n",
    "---\n",
    "\n",
    "Sin embargo, este método es muy tedioso y no es escalable: si tenemos una lista de 1000 elementos, tendríamos que escribir 1000 líneas para lograr nuestro objetivo.\n",
    "\n",
    "**We can use for loops instead! | En cambio, podemos usar for loops!**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "3\n",
      "5\n",
      "7\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "for impar in [1, 3, 5, 7, 9]:\n",
    "    print(impar)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A _for loop_ tells Python to execute some statements once for each value in a list, a character string, or some other collection.\n",
    "\n",
    "We can translate it as _\"for each thing in this group, do these operations\"_.\n",
    "\n",
    "---\n",
    "\n",
    "Un _for loop_ (o bucle) nos permite ejecutar determinadas sentencias una vez para cada valor de una lista, una cadena de caracteres (string) o cualquier otra colección.\n",
    "\n",
    "Podemos traducirlo como _\"para cada cosa de este grupo, realiza estas operaciones\"_."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Structure | Estructura\n",
    "\n",
    "For this example | Pra el siguiente ejemplo:\n",
    "\n",
    "```python\n",
    "for impar in [1, 3, 5, 7, 9]:\n",
    "    print(impar)\n",
    "```\n",
    "\n",
    "The structure of a _for loop_ consists of:\n",
    " - The **collection**, `[1, 3, 5, 7, 9]`, is what the loop is being run on.\n",
    " - The **body**, `print(impar)`, specifies what to do for each value in the collection.\n",
    " - The **loop variable** (the _\"current thing\"_), `impar`, is what changes for each iteration of the loop.\n",
    " \n",
    "---\n",
    "\n",
    "Todos los _for loops_ poseen la siguiente estructura:\n",
    " - La **colección**, `[1, 3, 5, 7, 9]`, sobre la cual se ejecutará el _for loop_.\n",
    " - El **cuerpo**, `print(impar)`, especifica qué se debe realizar para cada valor de la colección.\n",
    " - La **loop variable** (la _\"cosa actual\"_), `impar`, que va cambiando con cada iteración."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true,
    "tags": []
   },
   "source": [
    "The body can contain multiple statements | El cuerpo puede poseer múltiples sentencias"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 4 8\n",
      "3 9 27\n",
      "5 25 125\n"
     ]
    }
   ],
   "source": [
    "primos = [2, 3, 5]\n",
    "\n",
    "for primo in primos:\n",
    "    cuadrado = primo ** 2\n",
    "    cubo = primo ** 3\n",
    "    print(primo, cuadrado, cubo)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nevertheless, _for loops_ should be only a few lines long. It's hard for humans to keep long chunks of code in mind.\n",
    "\n",
    "---\n",
    "\n",
    "Sin embargo, es recomendable que los _for loops_ posean solo algunas líneas en el cuerpo. Es difícil para las personas recordar muchas líneas de código."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Formative assessment 1\n",
    "\n",
    "What will be the output the following code? | ¿Cuál será el output del siguiente código?\n",
    "\n",
    "```python\n",
    "for number in [2, 3, 5]:\n",
    "print(number)\n",
    "```\n",
    "\n",
    "1. We'll obtain | Obtenemos:\n",
    "    ```\n",
    "    1\n",
    "    2\n",
    "    3\n",
    "    ```\n",
    "2. An Error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "ename": "IndentationError",
     "evalue": "expected an indented block (350196295.py, line 2)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"/tmp/ipykernel_7575/350196295.py\"\u001b[0;36m, line \u001b[0;32m2\u001b[0m\n\u001b[0;31m    print(number)\u001b[0m\n\u001b[0m    ^\u001b[0m\n\u001b[0;31mIndentationError\u001b[0m\u001b[0;31m:\u001b[0m expected an indented block\n"
     ]
    }
   ],
   "source": [
    "# Solution | Solución\n",
    "\n",
    "for number in [2, 3, 5]:\n",
    "print(number)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "- The first line of a _for loop_ must end with a colon `:`.\n",
    "- The body of the _for loop_ must be indented.\n",
    "\n",
    "---\n",
    "\n",
    "- La primera línea de un _for loop_ debe finalizar con dos puntos `:`.\n",
    "- El cuerpo del _for loop_ debe indentarse."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Range\n",
    "\n",
    "We can use the built-in `range()` function to iterate over a sequence of numbers.\n",
    "\n",
    "- The `range` function creates numbers on demand, to make looping over a large amount of numbers more efficient.\n",
    "- It does not create a list of numbers!\n",
    "- `range(N)` will produce `N` numbers, specifically the ones in `0, 1, ..., N-1`.\n",
    "\n",
    "---\n",
    "\n",
    "Podemos usar la función `range()` para iterar sobre una secuencia de números.\n",
    "\n",
    "- La función `range` crea números bajo demanda, haciendo que los loops sobre grandes cantidades de números sean más eficientes.\n",
    "- No crea una lista de números!\n",
    "- `range(N)` generará `N` números: `0, 1, ..., N-1`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "for number in range(5):\n",
    "    print(number)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can specify a _start_, an _end_ and also a _step_ for the `range` function.\n",
    "\n",
    "---\n",
    "\n",
    "Alternativamente, podemos especificar un _valor inicial_, un _valor final_ y hasta un _paso_ para la función `range`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For example, if we want to print every even number between 10 and 30:\n",
    "\n",
    "---\n",
    "\n",
    "Por ejemplo, si queremos imprimir todos los pares del 10 al 30:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "12\n",
      "14\n",
      "16\n",
      "18\n",
      "20\n",
      "22\n",
      "24\n",
      "26\n",
      "28\n"
     ]
    }
   ],
   "source": [
    "for par in range(10, 30, 2):\n",
    "    print(par)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Formative assessment 2\n",
    "\n",
    "What would be the output of the following cell:\n",
    "\n",
    "```python\n",
    "for n in range(20)\n",
    "    print(n)\n",
    "```\n",
    "\n",
    "1. We get a syntax error. | Obtenemos un error de sintaxis.\n",
    "2. Python prints the numbers from 1 to 100, each one on their own line. | Python imprime los números del 1 al 100, cada uno en una línea distinta.\n",
    "3. Python prints the numbers from 0 to 99, each one on their own line. | Python imprime los números del 0 al 99, cada uno en una línea distinta."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (2933852483.py, line 3)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  Cell \u001b[0;32mIn [2], line 3\u001b[0;36m\u001b[0m\n\u001b[0;31m    for n in range(20)\u001b[0m\n\u001b[0m                      ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "# Solution | Solución \n",
    "\n",
    "for n in range(20)\n",
    "    print(n)\n",
    "    \n",
    "# The output is a syntax error\n",
    "# because we miss \":\".\n",
    "\n",
    "# El output es un error de sintaxis\n",
    "# porque no hemos colocado \":\". "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Formative assessment 3\n",
    "\n",
    "What would be the output of the following cell:\n",
    "\n",
    "```python\n",
    "for letra in \"coco\":\n",
    "    print(letra)\n",
    "```\n",
    "\n",
    "1. We get an error because we cannot use strings as a collection. / Obtenemos un error porque no podemos utilizar un string como una colección.\n",
    "2. Python prints 4 lines, each one with one of the letters in _coco_. / Python imprime 4 líneas, cada una con una de las letras de _coco_.\n",
    "    ```\n",
    "    c\n",
    "    o\n",
    "    c\n",
    "    o\n",
    "    ```\n",
    "3. Python prints 4 lines, each one with one of the numbers in `0, 1, 2, 3`. / Python imprime 4 líneas, cada una con uno de los números en `0, 1, 2, 3`.\n",
    "    ```\n",
    "    0\n",
    "    1\n",
    "    2\n",
    "    3\n",
    "    ```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Accumulator pattern | Algoritmo acumulador\n",
    "\n",
    "The accumulator pattern can help to turn many values into a single one.\n",
    "It usually consists of:\n",
    "- Initialize an _accumulator_ variable to zero, an empty string or an empty list.\n",
    "- Update the _accumulator_ variable with values from a collection.\n",
    "\n",
    "---\n",
    "\n",
    "Un algoritmo acumulador nos puede ayudar a convertir muchos valores en uno solo.\n",
    "Usualmente consiste en:\n",
    "- Inicializar una variable _acumuladora_ como cero, un string vacío o una lista vacía.\n",
    "- Actualizamos la variable _acumuladora_ con los valores de una dada colección."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For example, let's write an accumulator pattern to sum all the numbers from 1 to 10.\n",
    "\n",
    "---\n",
    "\n",
    "Por ejemplo, escribamos un acumulador que sume todos los números del 1 al 10."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "55\n"
     ]
    }
   ],
   "source": [
    "suma = 0\n",
    "\n",
    "for i in range(10):\n",
    "    # We add a 1 to i to add from 1 to 10 and not from 0 to 9 \n",
    "    # Le añadimos un 1 a i para sumar de 1 a 10 y no de 0 a 9\n",
    "    suma = suma + (i + 1)\n",
    "\n",
    "print(suma)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Small exercise**\n",
    "\n",
    "We could use the `+=` operator to simplify the body of the for loop. Research what the `+=` operator does and try to rewrite the previous accumulator using this operator.\n",
    "\n",
    "---\n",
    "\n",
    "Podríamos utilizar el operador `+=` para simplificar el cuerpo de nuestro for loop. Investiga qué hace el operador `+=` e intenta reescribir el acumulador anterior utilizando este operador.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Using a list as accumulator | Usando una lista como un acumulador\n",
    "\n",
    "In some cases, we might need to use a `list` as our _accumulator_ variable.\n",
    "For example, if we have a list of values and we want to create another list with their doubles.\n",
    "\n",
    "---\n",
    "\n",
    "En algunos casos es necesario utilizar una _lista_ como nuestra variable _acumuladora_.\n",
    "Por ejemplo, si tenemos una lista de valores y queremos crear una nueva lista que posea sus dobles."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will:\n",
    "- Define an empty list as our accumulator variable.\n",
    "- Fill it with the doubles of the values in the other list using the `.append()` method of the lists.\n",
    "\n",
    "---\n",
    "\n",
    "Para ello procederemos a:\n",
    "- Definir una lista vacía como nuestra variable acumuladora.\n",
    "- Llenarla de los dobles de los valores en la otra lista utilizando el método `.append()` de las listas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[8, 6.28, 16, 30]\n"
     ]
    }
   ],
   "source": [
    "originales = [4, 3.14, 8, 15]\n",
    "\n",
    "dobles = []\n",
    "\n",
    "for valor in originales:\n",
    "    doble = valor * 2\n",
    "    dobles.append(doble)\n",
    "    \n",
    "print(dobles)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conditional Statements | Sentencias Condicionales\n",
    "\n",
    "A conditional statement allows our code to make decisions based on some condition.\n",
    "For example, we can tell Python to execute a given statement only _if_ a given condition is met.\n",
    "In this lecture we will explore how to use the _if_ statement.\n",
    "\n",
    "---\n",
    "Una sentencia condicional permite a nuestro código tomar decisiones basado en una determinada condición.\n",
    "Por ejemplo, podemos decirle a Python que ejecute una determinada sentencia solo _si_ una dada condición es satisfecha.\n",
    "En esta lección exploraremos cómo utilizar la sentencia _if_."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The structure of an `if` statement is very similar to the `for` statement:\n",
    "- First line opens with an `if` followed by the **condition** and ends with a colon `:`.\n",
    "- The body of the `if` statement must be indented.\n",
    "\n",
    "---\n",
    "\n",
    "La estructura de la sentencia `if` es muy similar a la del `for`:\n",
    "- La primera línea comienza con `if` seguido por la **condición** y debe finalizar con dos puntos `:`.\n",
    "- El cuerpo de la sentencia `if` debe estar indentado."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.54 es grande\n"
     ]
    }
   ],
   "source": [
    "masa = 3.54\n",
    "\n",
    "if masa > 3:\n",
    "    print(masa, \"es grande\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "masa = 2.07\n",
    "\n",
    "if masa > 3:\n",
    "    print(masa, \"es grande\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `masa > 3` is the **condition** of the `if` statement.\n",
    "\n",
    "---\n",
    "\n",
    "`masa > 3` es la **condición** del `if`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Conditional operators | Operadores condicionales\n",
    "\n",
    "The _greater than_ `>` operator is a **conditional operator**. There are a few other conditional operators that we can use to compare the values of two variables.\n",
    "\n",
    "* `==`: equal to\n",
    "* `!=`: not equal to\n",
    "* `>`: greater than\n",
    "* `<`: lower than\n",
    "* `>=`: greater than or equal to\n",
    "* `<=`: lower than or equal to\n",
    "\n",
    "> **IMPORTANT**\n",
    ">\n",
    "> The `==` symbol represents the _equal to_ operator, while the `=` symbol is used for variable assignment.\n",
    "\n",
    "---\n",
    "\n",
    "El operador _mayor que_ `>` es un **operador condicional**. Hay algunos otros operadores condicionales que podemos utilizar para comparar los valores de dos variables.\n",
    "\n",
    "* `==`: igual a\n",
    "* `!=`: no igual a\n",
    "* `>`: mayor a\n",
    "* `<`: menor a\n",
    "* `>=`: mayor o igual a\n",
    "* `<=`: menor o igual a\n",
    "\n",
    "> **IMPORTANTE**\n",
    ">\n",
    "> El símbolo `==` representa el operador _igual a_, mientras que el símbolo `=` se utiliza para la asignación de variables."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Using `else` | Utilizando `else`\n",
    "\n",
    "We can use the `else` statement following the `if` for executing a block of code when the `if` condition is not met.\n",
    "\n",
    "---\n",
    "\n",
    "Podemos utilizar la sentencia `else` luego del `if` para ejecutar un bloque de código en caso de que la condición de `if` no se satisfaga."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.54 es grande\n"
     ]
    }
   ],
   "source": [
    "masa = 3.54\n",
    "\n",
    "if masa > 3:\n",
    "    print(masa, \"es grande\")\n",
    "else:\n",
    "    print(masa, \"es pequeña\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.07 es pequeña\n"
     ]
    }
   ],
   "source": [
    "masa = 2.07\n",
    "\n",
    "if masa > 3:\n",
    "    print(masa, \"es grande\")\n",
    "else:\n",
    "    print(masa, \"es pequeña\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Using `elif` | Utilizando `elif`\n",
    "\n",
    "If we have more than two alternative choices, we can use the `elif` statement (short for _else if_).\n",
    "\n",
    "---\n",
    "\n",
    "Cuando más de dos elecciones a tomar podemos hacer uso de `elif`, que es una versión reducida de _else if_."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9.07 es MUY grande\n"
     ]
    }
   ],
   "source": [
    "masa = 9.07\n",
    "\n",
    "if masa > 9:\n",
    "    print(masa, \"es MUY grande\")\n",
    "elif masa > 3:\n",
    "    print(masa, \"es grande\")\n",
    "else:\n",
    "    print(masa, \"es pequeña\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Formative assessment 4\n",
    "\n",
    "Which is the output of the following cell? | ¿Cuál es la salida de la siguiente celda?\n",
    "\n",
    "```python\n",
    "presion = 71.9\n",
    "if presion > 50.0:\n",
    "    presion = 25.0\n",
    "elif presion <= 50.0:\n",
    "    presion = 0.0\n",
    "print(presion)\n",
    "```\n",
    "\n",
    "1. 25.0\n",
    "2. 71.9\n",
    "3. 50.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "25.0\n"
     ]
    }
   ],
   "source": [
    "# Solution| Solución\n",
    "\n",
    "presion = 71.9\n",
    "if presion > 50.0:\n",
    "    presion = 25.0\n",
    "elif presion <= 50.0:\n",
    "    presion = 0.0\n",
    "print(presion)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "grade is C\n"
     ]
    }
   ],
   "source": [
    "grade = 85\n",
    "if grade >= 70:\n",
    "    print('grade is C')\n",
    "elif grade >= 80:\n",
    "    print('grade is B')\n",
    "elif grade >= 90:\n",
    "    print('grade is A')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "### Booleans and operators | Booleanos y operadores\n",
    "\n",
    "The `bool` variables are another type of variables, such as `int` or `float`, but `bools` can only have one of two values: `True` or `False`.\n",
    "Booleans are represented by a single bit.\n",
    "\n",
    "---\n",
    "\n",
    "Las variables de tipo `bool` son otro tipo de variables, tales como los `int` o los `float`, aunque los `bool` pueden asumir solo un valor entre dos: `True` o `False`.\n",
    "Los booleanos se representan por un único bit.\n",
    "\n",
    "\n",
    "Every time we evaluate a condition, we get a `bool` variable.\n",
    "For example:\n",
    "\n",
    "---\n",
    "\n",
    "Cada vez que evaluamos una cierta condición, obtenemos una variable de tipo `bool`.\n",
    "Por ejemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "temperatura = 20.3\n",
    "\n",
    "print(temperatura > 30)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also assign the output of `temperatura > 30` to another variable:\n",
    "\n",
    "----\n",
    "\n",
    "Incluso podemos asignar la salida de `temperatura > 30` a otra variable:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "<class 'bool'>\n"
     ]
    }
   ],
   "source": [
    "temperatura = 32.3\n",
    "\n",
    "hace_calor = temperatura > 30\n",
    "print(hace_calor)\n",
    "print(type(hace_calor))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Using `if` inside `for` loops | Usando `if` dentro de `for` loops\n",
    "\n",
    "It's very common to see `if` statementes **nested** inside `for` loops.\n",
    "\n",
    "---\n",
    "\n",
    "Es muy común ver sentencias `if` **anidadas** en `for` loops."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.54 es grande\n",
      "2.07 es pequeña\n",
      "9.22 es MUY grande\n",
      "1.86 es pequeña\n",
      "1.71 es pequeña\n"
     ]
    }
   ],
   "source": [
    "masas = [3.54, 2.07, 9.22, 1.86, 1.71]\n",
    "\n",
    "for masa in masas:\n",
    "    if masa > 9:\n",
    "        print(masa, \"es MUY grande\")\n",
    "    elif masa > 3:\n",
    "        print(masa, \"es grande\")\n",
    "    else:\n",
    "        print(masa, \"es pequeña\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "X60m1L_do3pu"
   },
   "source": [
    "## Functions | Funciones\n",
    "\n",
    "Once we start writing code to solve a problem we might end up with a large number of lines that are hard to navigate and understand.\n",
    "Human beings can only keep a few items in working memory at a time, so it's always better to break our programs down into **functions**.\n",
    "**Functions** can help us to **encapsulate** code so we can treat it as a _single thing_.\n",
    "They also enable the re-use of that code: _write one time, use many times_.\n",
    "\n",
    "So far, we have been using some built-in functions such as `print()`, `len()` and `type()`, and some functions that we found in certain libraries, like `np.linspace()` or `plt.plot()`.\n",
    "Here we will learn how we can write our own functions.\n",
    "\n",
    "----\n",
    "\n",
    "Una vez que comenzamos a escribir código para resolver un problema, podemos terminar con muchas líneas de código que son difíciles de navegar y entender.\n",
    "Los seres humanos pueden mantener solo unos pocos objetos en la memoria al mismo tiempo, por ende siempre es mejor dividir nuestros programas en **funciones**.\n",
    "Las **funciones** nos ayudan a **encapsular** código de forma tal que lo podamos tratar como una _única cosa_.\n",
    "Además nos permiten reutilizar ese código: _escribimos una única vez, lo usamos muchas veces_.\n",
    "\n",
    "En las últimas leccioens hemos utilizado algunas funciones _built-in_, como `print()`, `len()` o `type()`, y otras funciones que encontramos en algunas librerías, como `np.linspace()` or `plt.plot()`.\n",
    "Aquí vamos a aprender cómo podemos escribir nuestras propias funciones."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Structure of a function | Estructura de una función\n",
    "\n",
    "A function must always have the following structure:\n",
    "- Begin the definition of the function with the `def` statement.\n",
    "- It's followed by the name of the function\n",
    "    - Must follow the same rules as variable names\n",
    "- Then the _parameters_ (a.k.a _arguments_) inside parenthesis.\n",
    "    - If the function has no _parameters_, we must include empty parenthesis.\n",
    "    - We will talk more about parameters later.\n",
    "- Then a colon `:`\n",
    "- And finally the **body** of the function as an indented block of code.\n",
    "\n",
    "---\n",
    "\n",
    "Una función debe poseer siempre la siguiente estructura:\n",
    "- Comenzamos la definición de la función con una sentencia `def`.\n",
    "- Continuamos con el nombre de la función\n",
    "    - Debe seguir las mismas reglas que los nombres de las variables\n",
    "- Luego siguen los _parámetros_ (o _argumentos_) dentro de paréntesis.\n",
    "    - Si la función no posee parámetros, debemos incluir paréntesis vacíos.\n",
    "    - Discutiremos parámetros más adelante.\n",
    "- Luego colocamos dos puntos `:`.\n",
    "- Y finalizamos con el **cuerpo** de la función: un bloque de código indentado."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def saludo():\n",
    "    print(\"Hola!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When we **define** a function we are not running it.\n",
    "If we want to run it, we need to **call** it.\n",
    "\n",
    "---\n",
    "\n",
    "Al **definir** una función no la estamos ejecutando.\n",
    "Si deseamos ejecutarla necesitamos **llamarla**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hola!\n"
     ]
    }
   ],
   "source": [
    "saludo()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Arguments | Argumentos\n",
    "\n",
    "Most functions that we will write might need some input data.\n",
    "We can pass these data as _arguments_, also known as _parameters_.\n",
    "As we have seen, these _arguments_ must be specified when defining the function (inside the parentheses):\n",
    "\n",
    "- _Arguments_ become variables when the function is called.\n",
    "- They are assigned during the call, i.e. the values are passed to the function.\n",
    "- If you don't name the arguments when calling the function, they will be matched to parameters in the order in which the parameters are defined in the function.\n",
    "\n",
    "---\n",
    "\n",
    "La mayoría de las funciones que escribiremos pueden llegar a necesitar de algunos datos de entrada.\n",
    "Podemos pasar esos datos como _argumentos_, también conocidos como _parámetros_.\n",
    "Como hemos visto anteriormente, los _argumentos_ deben especificarse durante la definición de la función (dentro de los paréntesis).\n",
    "\n",
    "- Los _argumentos_ se transforman en variables cuando llamamos a la función.\n",
    "- Estos son asignados durante el llamado: sus valores se pasan a la función.\n",
    "- Si no nombramos los argumentos cuando llamamos a la función, ellos se asignan según el orden en el que están definidos en la función."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_fecha(anio, mes, dia):\n",
    "    fecha = str(anio) + \"/\" + str(mes) + \"/\" + str(dia)\n",
    "    print(fecha)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2022/2/4\n"
     ]
    }
   ],
   "source": [
    "print_fecha(2022, 2, 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2022/2/4\n"
     ]
    }
   ],
   "source": [
    "print_fecha(dia=4, mes=2, anio=2022)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As functions take input data, they can also produce _output_ data.\n",
    "We can tell functions to _return_ values to their caller using `return`.\n",
    "\n",
    "- Use `return ...` to give a value back to the caller.\n",
    "- May occur anywhere in the function.\n",
    "- But functions are easier to understand if return occurs:\n",
    "    - At the start to handle special cases.\n",
    "    - At the very end, with a final result.\n",
    "\n",
    "---\n",
    "\n",
    "Así como las funciones pueden tomar datos de entrada, también pueden producir datos de salida.\n",
    "Podemos indicar a las funciones que _entreguen_ valores a su _caller_ utilizando `return`.\n",
    "\n",
    "- Utilizamos `return ...` para devolver valores al _caller_.\n",
    "- El `return` puede aparecer en cualquier lugar del cuerpo de la función.\n",
    "- Pero las funciones son más fáciles de entender si el `return` se encuentra en:\n",
    "    - Al comienzo de la función, solo para cubrir casos especiales.\n",
    "    - Al final de la función, para devolver un resultado final."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "def promedio(valores):\n",
    "    if len(valores) == 0:\n",
    "        return None\n",
    "    return sum(valores) / len(valores)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.6666666666666665\n"
     ]
    }
   ],
   "source": [
    "a = promedio([1, 3, 4])\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n"
     ]
    }
   ],
   "source": [
    "b = promedio([])\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Remember**\n",
    "\n",
    "- Functions **always return something**\n",
    "- A function that doesn't explicitly `return` a value, it automatically returns `None`.\n",
    "\n",
    "---\n",
    "\n",
    "**Recuerda**\n",
    "\n",
    "- Las funciones **siempre devuelve algo**.\n",
    "- Una función que no devuelve explícitamente algo (no ejecuta una sentencia `return`), automáticamente devuelve `None`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2022/4/2\n"
     ]
    }
   ],
   "source": [
    "resultado = print_fecha(2022, 4, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n"
     ]
    }
   ],
   "source": [
    "print(resultado)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Formative assessment 5\n",
    "\n",
    "What would be the output of the following cell? | ¿Cuál sería la salida de la siguiente celda?\n",
    "\n",
    "```python\n",
    "def potencia(base, exponente):\n",
    "    return base ** exponente\n",
    "\n",
    "potencia(2)\n",
    "```\n",
    "\n",
    "1. `None`\n",
    "2. 2\n",
    "3. We get an error | Obtenemos un error\n",
    "4. 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "potencia() missing 1 required positional argument: 'exponente'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[0;32mIn [5], line 4\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mpotencia\u001b[39m(base, exponente):\n\u001b[1;32m      2\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m base \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39m exponente\n\u001b[0;32m----> 4\u001b[0m \u001b[43mpotencia\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m2\u001b[39;49m\u001b[43m)\u001b[49m\n",
      "\u001b[0;31mTypeError\u001b[0m: potencia() missing 1 required positional argument: 'exponente'"
     ]
    }
   ],
   "source": [
    "# Solution | Solución\n",
    "def potencia(base, exponente):\n",
    "    return base ** exponente\n",
    "\n",
    "potencia(2)\n",
    "\n",
    "# It is necessary to pass another argument.\n",
    "# Falto pasarle un argumento."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Correct solution | Solución correcta\n",
    "\n",
    "potencia(2, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Formative assessment 6\n",
    "\n",
    "We create the following function | Creamos la siguiente función:\n",
    "\n",
    "```python\n",
    "def print_time(hour, minute, second):\n",
    "    time_string = str(hour) + ':' + str(minute) + ':' + str(second)\n",
    "    print(time_string)\n",
    "```\n",
    "What will be the output of the following cell? | ¿Cuál sera el output de la siguiente celda?\n",
    "\n",
    "```python\n",
    "result = print_time(11, 37, 59)\n",
    "print('result of call is:', result)\n",
    "\n",
    "```\n",
    "\n",
    "1. It'll return | Devolverá:\n",
    "    ```\n",
    "    11:37:59\n",
    "    result of call is: None\n",
    "    ```\n",
    "    \n",
    "2. It'll return | Devolverá:\n",
    "    ```\n",
    "    result of call is: 11:37:59\n",
    "    ```\n",
    "    \n",
    "3. It'll return | Devolverá:\n",
    "    ```\n",
    "    11:37:59\n",
    "    result of call is: 11:37:59\n",
    "    ```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "11:37:59\n",
      "result of call is: None\n"
     ]
    }
   ],
   "source": [
    "# Solution | Solución\n",
    "\n",
    "def print_time(hour, minute, second):\n",
    "    time_string = str(hour) + ':' + str(minute) + ':' + str(second)\n",
    "    print(time_string)\n",
    "    \n",
    "result = print_time(11, 37, 59)\n",
    "print('result of call is:', result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "### Documenting our functions | Documentando nuestras funciones\n",
    "\n",
    "One of the best practices when writing functions is to document their behaviour, describing which parameters it needs, what the function does, and which parameters it returns.\n",
    "\n",
    "We can easily document these things inside the `docstring`.\n",
    "\n",
    "---\n",
    "\n",
    "Una de las mejores prácticas a la hora de escribir funciones es documentar su comportamiento, describiendo qué parámetros necesita, qué hace la función y qué parámetros devuelve.\n",
    "\n",
    "Podemos documentar esto sencillamente dentro de los `docstring`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "def suma(x, y):\n",
    "    \"\"\"\n",
    "    Suma dos valores\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    x : float or array\n",
    "        Primer sumando\n",
    "    y : float or array\n",
    "        Segundo sumando\n",
    "    \n",
    "    Returns\n",
    "    -------\n",
    "    resultado : float or array\n",
    "        Resultado de la suma\n",
    "    \"\"\"\n",
    "    return x + y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can read the _docstring_ of any function through the `help()` function or with the `?`, even our own functions!\n",
    "\n",
    "---\n",
    "\n",
    "Podemos leer el _docstring_ de cualquier función mediante la función `help()` o con el símbolo `?`, incluso de nuestras propias funciones!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function suma in module __main__:\n",
      "\n",
      "suma(x, y)\n",
      "    Suma dos valores\n",
      "    \n",
      "    Parameters\n",
      "    ----------\n",
      "    x : float or array\n",
      "        Primer sumando\n",
      "    y : float or array\n",
      "        Segundo sumando\n",
      "    \n",
      "    Returns\n",
      "    -------\n",
      "    resultado : float or array\n",
      "        Resultado de la suma\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(suma)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[0;31mSignature:\u001b[0m \u001b[0msuma\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
       "\u001b[0;31mDocstring:\u001b[0m\n",
       "Suma dos valores\n",
       "\n",
       "Parameters\n",
       "----------\n",
       "x : float or array\n",
       "    Primer sumando\n",
       "y : float or array\n",
       "    Segundo sumando\n",
       "\n",
       "Returns\n",
       "-------\n",
       "resultado : float or array\n",
       "    Resultado de la suma\n",
       "\u001b[0;31mFile:\u001b[0m      /tmp/ipykernel_7575/770818275.py\n",
       "\u001b[0;31mType:\u001b[0m      function\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "suma?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Remember | Recordar**\n",
    "\n",
    "In Jupyter Notebook, we can use `Shift+Tab` while our cursor is standing on top of the function name to see the docstring in a popup.\n",
    "\n",
    "---\n",
    "\n",
    "En Jupyter Notebooks podemos utilizar `Shift+Tab` mientras el cursor se encuentra sobre el nombre de la función para ver su docstring en un popup."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Default arguments | Argumentos por defecto\n",
    "\n",
    "Sometimes we want some argument of our functions to have a default value, so we don't need to pass it every time we call a function.\n",
    "We can do this by definining a **default argument**.\n",
    "\n",
    "----\n",
    "\n",
    "En algunas ocasiones deseamos que algún argumento de nuestra función posea un valor por defecto, de forma tal que no necesitemos especificarlo cada vez que llamamos a la función.\n",
    "Es posible establecer valores por defecto mediante la definición de **argumentos por defecto**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "def seno(x, freq=np.pi / 2):\n",
    "    \"\"\"\n",
    "    Define función seno con una dada frecuencia\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    x : float or array\n",
    "        Abscisa sobre la cual se evaluará el seno\n",
    "    freq : float (optional)\n",
    "        Frecuencia de la función seno\n",
    "    \n",
    "    Returns\n",
    "    -------\n",
    "    seno : float or array\n",
    "        Seno de x * freq\n",
    "    \"\"\"\n",
    "    seno = np.sin(freq * x)\n",
    "    return seno\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can safely call the function by passing the `x` argument only: the `freq` argument will be `np.pi / 2` by default.\n",
    "\n",
    "---\n",
    "\n",
    "Podemos llamar a la función pasando únicamente el argumento `x`: el argumento `freq` asumirá el valor `np.pi / 2` por defecto."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "seno(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we want to change the value of any _default argument_, we need to pass a different value for it.\n",
    "\n",
    "---\n",
    "\n",
    "Si queremos modificar el valor de cualquier _argumento por defecto_, necesitamos pasar un valor diferente para él."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.7071067811865475"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "seno(1, freq=np.pi/4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Homework"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Before doing your homework, _create_ a notebook called `homework_more_python.ipynb` into your _local repository_ called `coco_coding_homework`.\n",
    "There you will _solve the activities_ proposed below.\n",
    "Then, _push_ the notebook with the solution into the your _remote repository_ in your GitHub account.\n",
    "In this way, one of the trainers will be able to see your answers and give you feedback.\n",
    "\n",
    "---\n",
    "\n",
    "Antes de hacer la tarea, _cree_ un notebook llamado `homework_more_python.ipynb`  en su _repositorio local_ llamado `coco_coding_homework`.\n",
    "Allí es donde _resolverá las actividades_ propuestas a continuación.\n",
    "Luego haga un _push_ del notebook con las respuestas al _repositorio remoto_ en su cuenta de GitHub.\n",
    "De esta forma, alguno de los trainers podrá ver sus respuestas y darle una devolución de las actividades resueltas.\n",
    "\n",
    "### 1° Task\n",
    "\n",
    "1. Convert the following list of temperatures in Fahrenheit to Celsius with a for loop.\n",
    "   `temperatures_f = [30.2, 41, 115.7, 77, 130.46, 59, 86, 63.5, 23]`\n",
    "   > Help: It may be useful to create an empty list where we store the temperature data in Celsius and add values to it with the append method.\n",
    "2. Use for loops and conditionals to generate a temperature alert for:\n",
    "    - low temperatures (less or equal than 0°C)\n",
    "    - high temperatures (greater or equal than 35°C)\n",
    "    - normal temperatures (between 0°C and 35°C)\n",
    "3. Generate two functions:\n",
    "    - a function that takes a single value of temperature in Fahrenheit and returns the same value in Celsius.\n",
    "    - a function that takes a single temperature value and prints its corresponding temperature alert.\n",
    "    \n",
    "    Use a for loop to iterate over the temperature values in Fahrenheit: convert the value to Celsius and print the alert. Use the two functions to do so.\n",
    "\n",
    "\n",
    "**Don't forget to document your functions!**\n",
    "\n",
    "---\n",
    "\n",
    "1. Convierte la siguiente lista de temperaturas en Fahrenheit a grados Centígrados usando un for loop.\n",
    "    `temperaturas_f = [30.2, 41, 115.7, 77, 130.46, 59, 86, 63.5, 23]`\n",
    "    > Ayuda: Quizás sea útil crear una lista vacía donde guardemos los datos de temperatura en Celsius e ir agregándole valores con el método append\n",
    "2. Utiliza for loops y condicionales para generar una alerta para temperaturas:\n",
    "    - bajas temperaturas (menores o iguales a 0°C)\n",
    "    - altas temperaturas (mayores o iguales a 35°C)\n",
    "    - temperaturas normales (entre 0°C y 35°C)\n",
    "3. Genera dos funciones:\n",
    "    - una función que toma un único valor de temperatura en Fahrenheit y devuelve el mismo valores pero en Celsius.\n",
    "    - una función que toma un único valor de temperatura e imprime su correspondiente alerta de temperatura\n",
    "    \n",
    "    Utiliza un for loop que itere sobre cada valor de temperatura en Fahrenheit: convierte el valor a Celsius e imprime la alerta. Utiliza las dos funciones que definiste para ello.\n",
    "   \n",
    "**No te olvides de documentar tus funciones!**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2° Task\n",
    "\n",
    "Your local airport is famous for its bad weather conditions.\n",
    "They need a tower operator to be constantly monitoring the weather conditions, specially the **wind speed** and the **visibility**.\n",
    "- If the **wind speed** is greater than 12 knots, then the runway must be closed and no plane can takeoff.\n",
    "- If the **visibility** is lower than 100 meters, they should also close the runway.\n",
    "- If the **wind speed** is between 8 kt and 12 kt, they should warn pilots of high wind speeds.\n",
    "- If the **visiblity** is between 100 meters and 500 meters, they should warn pilots of low visibilty conditions.\n",
    "- On any other situation, the weather is good enough so the runway is open and no warning should be issued.\n",
    "\n",
    "They want to automate this warning system so the operator can have more  time to assist pilots.\n",
    "\n",
    "Write a function that takes **wind speed** in knots and **visibility** in meters.\n",
    "The function must raise warnings of high wind speeds or low visiblity conditions, or even close the runway if the weather conditions are bad enough.\n",
    "\n",
    "As a condition, the function must not have `print` statements, instead it should return strings like `\"good weather\"`, `\"low visibility conditions\"` or `\"bad weather: close runway\"`. Be creative!\n",
    "\n",
    "Feel free to test your function against some combinations of **wind speed** and **visiblity**.\n",
    "\n",
    "> **Help**:<br>\n",
    "> Explore how you can use the `and` and `or` operators in your `if` and `elif` statements.\n",
    "\n",
    "---\n",
    "\n",
    "Tu aeropuerto local es famoso por sus malas condiciones climáticas.\n",
    "Una operadora de la torre necesita estar monitoreando constamente las condiciones climáticas, especialmente la **velocidad del viento** y la **visiblidad**.\n",
    "- Si la **velocidad del viento** es mayor a 12 nudos, entonces la pista debe cerrarse y ningúnx piloto puede despegar.\n",
    "- Si la **visibilidad** es menor que 100 metros, tambien deben cerrar la pista.\n",
    "- Si la **velocidad del viento** está entre 8 nudos y 12 nudos, deben advertir a lxs pilotos sobre vientos fuertes. \n",
    "- Si la **visiblidad** está entre 100 metros y 500 metros, deben advertir a lxs pilotos sobre bajas condiciones de visibilidad.\n",
    "- En cualquier otra situacion, las condiciones climáticas se consideran buenas y por ende la pista se encuentra abierta y ninguna advertencia debe ser emitida.\n",
    "\n",
    "El aeropuerto quiere automatizar este sistema de alertas así la operadora puede tener más tiempo para asistir a lxs pilotos.\n",
    "\n",
    "Escribe una función que toma la **velocidad del viento** en nudos y la **visibilidad** en metros.\n",
    "La función debe alertar de vientos fuertes o condiciones de bajas visiblidad, o incluso cerrar la pista si las condiciones climáticas son los suficientemente malas.\n",
    "\n",
    "Como condición, la función no debe poseer `print`s, en cambio, debe _devolver_ strings como `\"buen tiempo\"`, `\"baja visibilidad\"` o \"`mal tiempo: cierre la pista\"`. Se creativx!\n",
    "\n",
    "Sientete libre de _testear_ tu función con algunas combinaciones de **velocidad del viento** y **visibilidad**.\n",
    "\n",
    "\n",
    "> **Ayuda**:<br>\n",
    "> Explora cómo puedes utilizar los operadores `and` y `or` en tus sentencias `if` y `elif`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3° Task\n",
    "\n",
    "In the previous notebook we repeatedly graphed a zero-centered Gaussian function by modifying the sigma parameter:\n",
    "\n",
    "$$ g(x) = \\frac{1}{\\sigma\\sqrt{2\\pi}} e^{ -\\frac{1}{2}\\left(\\frac{x}{\\sigma}\\right)^2}$$\n",
    "\n",
    "This task could have been easier if we had encapsulated the Gaussian function within a Python function.\n",
    "In addition, defining functions to perform calculations helps us prevent mistake.\n",
    "Especially, if we create a function with good documentation that we can use in the future.\n",
    "These habits (among others) are part of what is known as good practices for software development.\n",
    "\n",
    "1. Write a function that evaluates the Gaussian function and returns its value.\n",
    "2. This function must be able to accept a value of $\\sigma$ as an argument, assuming it by default equal to 1.\n",
    "3. Add a detailed documentation of the Gaussian function. What does the function do? What arguments does it support? What values does it return?\n",
    "4. Select at least three different values of $\\sigma$ and plot the Gaussians using a for loop.\n",
    "\n",
    "**Bonus track**\n",
    "\n",
    "The generalized expression of the Gaussian function is:\n",
    "\n",
    "$$ g(x) = \\frac{1}{\\sigma\\sqrt{2\\pi}} e^{ -\\frac{1}{2}\\left(\\frac{x-\\mu}{\\sigma}\\right)^2}$$\n",
    "\n",
    "Where $\\mu$ indicates the abscissa corresponding to the peak of the function.\n",
    "\n",
    "1. Generalize the above function to allow an additional argument mu, with a default value equal to 0.\n",
    "2. Update the function documentation for the new value.\n",
    "3. Select at least three different values of $ \\mu $ and plot the Gaussians for the same value of $ \\sigma $.\n",
    "\n",
    "---\n",
    "\n",
    "En el notebook anterior graficamos repetidas veces una función gaussiana centrada en cero modificando el parámetro sigma:\n",
    "\n",
    "$$ g(x) = \\frac{1}{\\sigma\\sqrt{2\\pi}} e^{ -\\frac{1}{2}\\left(\\frac{x}{\\sigma}\\right)^2}$$\n",
    "\n",
    "Esta tarea podría haber sido más fácil si hubieramos encapsulado la función gaussiana dentro de una función de Python.\n",
    "Además, definir funciones para realizar cálculos nos ayuda a prevenir errores.\n",
    "Especialmente si creamos una función con buena documentación que podemos usar en el futuro.\n",
    "Estos hábitos (entre otros) forman parte de lo que se conoce como buenas prácticas para el desarrollo de software.\n",
    "\n",
    "1. Escribir una función que evalúe la función Gaussiana y devuelva su valor.\n",
    "2. Dicha función debe poder admitir un valor de $\\sigma$ como argumento, asumiéndolo por defecto igual a 1.\n",
    "3. Añadir una documentación detallada de la función gaussiana. ¿Qué hace la función? ¿Qué argumentos admite? ¿Qué valores devuelve?\n",
    "4. Seleccionar al menos tres valores diferentes de $\\sigma$ y graficar las gaussianas usando un for loop.\n",
    "\n",
    "**Bonus track**\n",
    "\n",
    "La expresión generalizada de la función gaussiana es:\n",
    "\n",
    "$$ g(x) = \\frac{1}{\\sigma\\sqrt{2\\pi}} e^{ -\\frac{1}{2}\\left(\\frac{x-\\mu}{\\sigma}\\right)^2} $$\n",
    "\n",
    "Donde $\\mu$ indica la abscisa correpondiente al pico de la función.\n",
    "\n",
    "1. Generalice la función anterior para que admita un argumento adicional mu, con valor por defecto igual a 0.\n",
    "2. Actualice la documentación de la función para el nuevo valor.\n",
    "3. Seleccione al menos tres valores diferentes de $\\mu$ y grafique las gaussianas para un mismo valor de $\\sigma$.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Extra material to keep learning | Material extra para seguir aprendiendo\n",
    "\n",
    "* From Programming with Python by Software carpentry: \n",
    "    * [Repeating Actions with Loops](https://swcarpentry.github.io/python-novice-inflammation/05-loop/index.html)\n",
    "    * [Making Choices](https://swcarpentry.github.io/python-novice-inflammation/07-cond/index.html)\n",
    "    * [Creating Functions](https://swcarpentry.github.io/python-novice-inflammation/08-func/index.html#programming-with-python)\n",
    "* [Plotting and Programming in Python](https://swcarpentry.github.io/python-novice-gapminder/) by Software Carpentry\n",
    "* [Introduction to python](https://johnfoster.pge.utexas.edu/numerical-methods-book/PythonIntro.html)\n",
    "* [Geo-Python](https://geo-python-site.readthedocs.io/en/latest/index.html)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.13"
  },
  "toc-showcode": false
 },
 "nbformat": 4,
 "nbformat_minor": 4
}