04_intro_to_python_numpy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"media/coco-banner.jpg\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "# Welcome to learning Python!\n",
    "\n",
    "These notebooks contain a mix of text and code. \n",
    "This makes it easy to experiment with code and keep documentation like this in the same place. \n",
    "You can execute each cell individually, and therefore work incrementally with your code. \n",
    "\n",
    "If you want to execute a cell, you can press the `►` button above when you have highlighted the cell. \n",
    "Alternatively, you can hit `Shift + Enter` to execute and progress to next cell or alternatively `Ctrl + Enter` (Windows) or `Cmd + Enter` (Mac). \n",
    "_Take your time to experiment with it if you like and don't hesitate to ask or search for things in your favorite browser._\n",
    "\n",
    "----\n",
    "\n",
    "Estos notebooks contienen una combinación de texto y código, lo que facilita la experimentación con el código y mantiene una documentación como esta en el mismo lugar. \n",
    "En los notebooks se puede ejecutar cada celda individualmente y, por lo tanto, trabajar de forma incremental con tu código. \n",
    "\n",
    "Si deseas ejecutar una celda, puedes presionar el botón `►` de arriba cuando se haya resaltado la celda o presionar `Shift + Enter` para ejecutar y avanzar a la siguiente celda. Puedes usar alternativamente `Ctrl + Enter` (Windows) o `Cmd + Enter` (Mac).\n",
    "_Tómate tu tiempo para experimentar con él si quieres y no dudes en preguntar o buscar cosas en tu navegador favorito._"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Introduction to Python | Introducción a Python\n",
    "\n",
    "\n",
    "**In this notebook we will learn about | En este notebook aprenderemos sobre:**\n",
    "* Variables | Variables\n",
    "* Types of data | Tipo de datos\n",
    "* Different data structures |  Diferentes estructuras de datos\n",
    "* Working with NumPy arrays | Trabajar con NumPy arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Variables and data type | Variables y tipos de datos \n",
    "\n",
    "A _variable_ allows us to store a value.\n",
    "In Python, we can assign a value to a variable using the equals sign `=`.\n",
    "\n",
    "----\n",
    "\n",
    "Una _variable_ nos permite almacenar un valor en un lugar determinado. \n",
    "En Python usamos el símbolo `=` para asignar un valor a una variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "alumni = 15\n",
    "\n",
    "course_name = \"CoCo\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The keyword `print()` is a function in Python. We can use it to see the value stored in the variable.\n",
    "\n",
    "----\n",
    "\n",
    "`print()` es una función en Python, que usamos para examinar el valor asignado a una variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15\n"
     ]
    }
   ],
   "source": [
    "print(alumni)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Moreover, variables can easily be updated. | Además, las variables se pueden actualizar fácilmente."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "35\n"
     ]
    }
   ],
   "source": [
    "alumni = 35\n",
    "\n",
    "print(alumni)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CoCo course has 35 alumni\n"
     ]
    }
   ],
   "source": [
    "print(course_name, \"course has\", alumni, \"alumni\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Data Types | Tipos de datos**\n",
    "\n",
    "There are several different data types that we will be exploring in the course. | Hay diferentes tipos de datos que vamos a ver en el curso.\n",
    "\n",
    "* integers (int): integer numbers | números enteros.\n",
    "* strings (str): sequence of alphanumeric text or other symbols | cadena de caracteres.\n",
    "* floats (float): representation of real numbers | valores de punto flotante (representación aproximada de números reales).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(alumni)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(course_name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "17.5 is <class 'float'>\n"
     ]
    }
   ],
   "source": [
    "half_alumni = alumni / 2\n",
    "\n",
    "print(half_alumni, \"is\", type(half_alumni))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "#### Formative assessment 1\n",
    "\n",
    "What will be the output of the next cell? | ¿Cual será el output de la siguiente celda?\n",
    "\n",
    "```python\n",
    "channel = 100.\n",
    "type(channel)\n",
    "```\n",
    "\n",
    "1. int\n",
    "\n",
    "2. float\n",
    "\n",
    "3. str"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Solution | Solución\n",
    "\n",
    "channel = 100.\n",
    "type(channel)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you want to concatenate two or more strings, there are several ways to achieve this in Python. \n",
    "The simplest method is to use `+`\n",
    "\n",
    "---\n",
    "\n",
    "Si desea concatenar dos o más cadenas de caracteres hay varias formas de hacerlo.\n",
    "La más común es usar `+`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hola mundo\n"
     ]
    }
   ],
   "source": [
    "saludo = \"hola\" + \" \" + \"mundo\"\n",
    "\n",
    "print(saludo)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Formative assessment 2\n",
    "\n",
    "We have a file in the following path: `data/hawaii-profile.csv`. What will happen if we run the following code? \n",
    "\n",
    "---\n",
    "\n",
    "Tenemos un archivo en el siguiente path: `data/hawaii-profile.csv` ¿Qué pasá si ejecutamos el siguiente código?\n",
    "\n",
    "```python\n",
    "path = data/hawaii-profile.csv\n",
    "print(path)\n",
    "```\n",
    "\n",
    "1. Return an error | Devuelve un error\n",
    "\n",
    "2. Return the value stored in the `path` variable as | Devuelve el valor alojado en la variable `path` como: `data/data.csv`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'data' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "Input \u001b[0;32mIn [10]\u001b[0m, in \u001b[0;36m<cell line: 3>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[38;5;66;03m# Solution | Solución \u001b[39;00m\n\u001b[0;32m----> 3\u001b[0m path \u001b[38;5;241m=\u001b[39m \u001b[43mdata\u001b[49m\u001b[38;5;241m/\u001b[39mdata\u001b[38;5;241m.\u001b[39mcsv\n\u001b[1;32m      4\u001b[0m \u001b[38;5;28mprint\u001b[39m(path)\n",
      "\u001b[0;31mNameError\u001b[0m: name 'data' is not defined"
     ]
    }
   ],
   "source": [
    "# Solution | Solución \n",
    "\n",
    "path = data/data.csv\n",
    "print(path)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We define the variable path as an string, so we need to use \"\"\n",
    "\n",
    "---\n",
    "\n",
    "Estamso definiendo la variable path como una cadena de caracteres, por lo tanto debemos usar \"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "data/data.csv\n",
      "<class 'str'>\n"
     ]
    }
   ],
   "source": [
    "# Correct answer | Respuesta correcta\n",
    "\n",
    "path = \"data/data.csv\"\n",
    "print(path)\n",
    "print(type(path))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "### Mathematical operations | Operaciones matemáticas\n",
    "\n",
    "All of the standard calculator arithmetic operations are available between variables.\n",
    "We measure a certain geophysical variable at a height of 53.2 meters above sea level. \n",
    "\n",
    "---\n",
    "\n",
    "Podemos aplicar diferentes operaciones aritméticas entre distintas variables.\n",
    "Medimos una determinada variable geofísica a una altura de 53.2 metros sobre el nivel del mar."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "sea_height = 53.2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "53.2"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sea_height"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Addition | Suma**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "63.800000000000004"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sea_height + 10.6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "49.7"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sea_height - 3.5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Multiplication | Multiplicación**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "106.4"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sea_height * 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Division | División**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "26.6"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sea_height / 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "26.0"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sea_height // 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Power | Potencia**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2830.2400000000002"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sea_height ** 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Formative Assessment 3\n",
    "\n",
    "What values do the variables mass and age have after each of the following statements?\n",
    "\n",
    "---\n",
    "\n",
    "¿Qué valores tienen las variables masa y edad después de cada una de las siguientes afirmaciones?\n",
    "\n",
    "```\n",
    "mass = 47.5\n",
    "age = 122\n",
    "mass = mass * 2.0\n",
    "age = age - 20\n",
    "\n",
    "```\n",
    "1. `mass = 47.5` and `age` does not exist\n",
    "\n",
    "2. `mass = 47.5` and `age =  122` \n",
    "\n",
    "3. `mass = 95.0` and `age = 122`\n",
    "\n",
    "4. `mass = 95.0` and `age = 102`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "mass: 95.0 age: 102\n"
     ]
    }
   ],
   "source": [
    "# Solution | Solución\n",
    "\n",
    "mass = 47.5\n",
    "age = 122\n",
    "mass = mass * 2.0\n",
    "age = age - 20\n",
    "\n",
    "print(\"mass:\", mass, \"age:\", age)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "### Data Structures | Estructura de datos\n",
    "\n",
    "A data structure is a term to describe a type of \"data container\". \n",
    "They are used to store multiples of variables and provide certain accessor functions to extract them from the container. \n",
    "\n",
    "---\n",
    "\n",
    "Una estructura de datos es un término para describir un tipo de \"contenedor de datos\".\n",
    "Se utilizan para almacenar múltiples variables y proporciona ciertas funciones de acceso para extraerlas del contenedor. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Lists | Listas\n",
    "\n",
    "Python lists are used to store a _collection of data_.\n",
    "A list is composed of comma-separated values between square brackets.\n",
    "\n",
    "---\n",
    "\n",
    "Las listas nos permiten _guardar múltiples valores bajo una misma variable_.\n",
    "Una lista es una lista de valores separados por comas entre corchetes.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "list"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "impares = [1, 3, 5, 7, 9]\n",
    "\n",
    "type(impares)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3, 5, 7, 9]"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "impares"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lists can store heterogeneous data, and you can even have lists of lists. | Las listas pueden contener datos heterogéneos (diferentes tipos de variables), hasta listas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['agua', 20.1, 52]\n"
     ]
    }
   ],
   "source": [
    "list_heterogeneous = [\"agua\", 20.1, 52]\n",
    "\n",
    "print(list_heterogeneous)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1, 2, 3], 3.0, 'hielo']\n"
     ]
    }
   ],
   "source": [
    "lista_anidadas = [[1, 2, 3], 3.0, \"hielo\"]\n",
    "\n",
    "print(lista_anidadas)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use the `append` function to add items to the end of a list. | Usamos la función `append` para agregar un elemento al final de la lista."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 3, 5, 7, 9, 11]\n"
     ]
    }
   ],
   "source": [
    "impares.append(11)\n",
    "\n",
    "print(impares)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Formative Assessment 4\n",
    "\n",
    "We want to add two more element to the `impares` list, so, what will happen if we execute the following code?\n",
    "\n",
    "---\n",
    "\n",
    "Queremos agregar 2 elemento más a la lista `impares`. ¿Qué pasa si ejecutamos el siguiente código?: \n",
    "\n",
    "```python\n",
    "impares = [1, 3, 5, 7, 9]\n",
    "impares.append[[15, 17])\n",
    "print(impares)\n",
    "```\n",
    "\n",
    "1. Return the `impares` list with the two new elements | Devuelve la lista `impares` con los 2 elementos nuevos:\n",
    "```\n",
    "[1, 3, 5, 7, 9, 11, 15, 17]\n",
    "```\n",
    "\n",
    "2. Return the `impares` list as a nested list, where the last element is a list | Devuelve la lista `impares` como una lista anidada donde el último elemento es una lista:\n",
    "```\n",
    "[1, 3, 5, 7, 9, 11, [15, 17]]\n",
    "``` "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 3, 5, 7, 9, [15, 17]]\n"
     ]
    }
   ],
   "source": [
    "# Solution | Solución\n",
    "\n",
    "impares = [1, 3, 5, 7, 9]\n",
    "impares.append([15, 17])\n",
    "print(impares)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we want to add more than one element to the list, we can't use the `append` function.\n",
    "So, we must use the `extend` function or concatenate two lists using `+`\n",
    "\n",
    "---\n",
    "\n",
    "Si queremos agregar más de 1 elemento a una lista no podemos usar la función `append`.\n",
    "Para eso debemos usar la función `extend` o concatenar listas usando `+`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3, 5, 7, 9, [15, 17], 19, 21]"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "impares.extend([19, 21])\n",
    "impares"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3, 5, 7, 9, [15, 17], 19, 21, 23, 25, 27]"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "impares = impares + [23, 25] + [27]\n",
    "\n",
    "impares"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can access the values housed in a list through their indices. | Podemos acceder a los valores alojados dentro de una lista a través de sus índices."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "temperaturas = [10.1, 14.6, 18.3, 20.3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[10.1, 14.6, 18.3, 20.3]"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "temperaturas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10.1"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "temperaturas[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Primer valor de temperatura: 10.1\n",
      "Segundo valor de temperatura: 14.6\n",
      "Último valor de temperatura: 20.3\n",
      "Penúltimo valor de temperatura: 18.3\n"
     ]
    }
   ],
   "source": [
    "print(\"Primer valor de temperatura:\", temperaturas[0])\n",
    "print(\"Segundo valor de temperatura:\", temperaturas[1])\n",
    "print(\"Último valor de temperatura:\", temperaturas[-1])\n",
    "print(\"Penúltimo valor de temperatura:\", temperaturas[-2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Observations | Observaciones**\n",
    "\n",
    "* In Python, the **0 index is the first element** of the list.\n",
    "* Negative indices indicate that we start counting from the last item in the list.\n",
    "* **Lists don't have a fixed length**, we can change them as we need.\n",
    "\n",
    "---\n",
    "\n",
    "* En Python, **el índice 0 indica el primer elemento** de la lista.\n",
    "* Índices negativos indican que empezamos a contar desde el último elemento de la lista.\n",
    "* **Las listas no tienen una longitud fija**, podemos cambiarla según lo necesitemos."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The indices also allow us to modify the values of the list. | Los índices además nos permiten modificar los valores de la lista."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Temperature before: \", temperaturas)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Temperature before:  [10.1, 14.6, 18.3, 20.3]\n",
      "Temperature after: [-2.3, 14.6, 18.3, 20.3]\n"
     ]
    }
   ],
   "source": [
    "temperaturas[0] = -2.3\n",
    "\n",
    "print(\"Temperature after:\", temperaturas)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We use `len` to find out how many values are in a list. | Usamos la función `len` para ver cuántos elementos tiene una lista."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(temperaturas)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In case we want to extract a _slice of the list_ instead of a single element, it is possible.\n",
    "If we want to obtain all the elements from the second to the fourth, without including the fourth one:\n",
    "\n",
    "---\n",
    "\n",
    "En caso de que queramos _extraer una porción_ de la lista en vez de un sólo elemento, es posible utilizar _slices_ o _porciones_.\n",
    "Si queremos obtener todos los elementos desde el segundo hasta el cuarto, sin incluir:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[14.6, 18.3, 20.3]"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "temperaturas[1:4]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we want to choose the first three elements: | Si queremos elegir los primeros tres elementos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[-2.3, 14.6, 18.3]"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "temperaturas[:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Similarly, if we want to get all the elements after the third element. | De manera similar, si queremos obtener todos los elementos después del tercero."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[20.3, 23.5]"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "temperaturas[3:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How can we use a _slice_ to access all elements except the last one? | ¿Cómo podemos usar un _slice_ para acceder a todos sus elementos menos el último?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[-2.3, 14.6, 18.3, 20.3]"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "temperaturas[:-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Can you create an empty list? | ¿Se puede crear una lista vacía?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lista_vacia = []\n",
    "\n",
    "lista_vacia"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1]"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lista_vacia.append(1)\n",
    "\n",
    "lista_vacia"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Formative assessment 5\n",
    "\n",
    "Let's define a list `my_list = [-3.0, -2.0, -1.0]`. What happens if we try to get the element with index 3 of the list, i.e. `my_list[3]`?\n",
    "\n",
    "---\n",
    "\n",
    "Definamos una lista `mi_lista = [-3.0, -2.0, -1.0]`. ¿Qué sucede si intentamos acceder al elemento con índice 3 de la lista, es decir `mi_lista[3]`?\n",
    "\n",
    "\n",
    "1. We get `-1.0` | Obtenemos `-1.0`\n",
    "\n",
    "2. We get an Error | Obtenemos un Error\n",
    "\n",
    "3. We get `-3.0` | Obtenemos `-3.0`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "ename": "IndexError",
     "evalue": "list index out of range",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "Input \u001b[0;32mIn [1]\u001b[0m, in \u001b[0;36m<cell line: 5>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[38;5;66;03m# Solution | Solución\u001b[39;00m\n\u001b[1;32m      3\u001b[0m lista \u001b[38;5;241m=\u001b[39m [\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m3.0\u001b[39m, \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m2.0\u001b[39m, \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1.0\u001b[39m]\n\u001b[0;32m----> 5\u001b[0m \u001b[43mlista\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m3\u001b[39;49m\u001b[43m]\u001b[49m\n",
      "\u001b[0;31mIndexError\u001b[0m: list index out of range"
     ]
    }
   ],
   "source": [
    "# Solution | Solución\n",
    "\n",
    "lista = [-3.0, -2.0, -1.0]\n",
    "\n",
    "lista[3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Tuple | Tupla\n",
    "\n",
    "_Tuples_ are like lists, but inmutable. \n",
    "If you have data that you want to store in a structure, but you know it will not be changed, tuples can be more efficient.\n",
    "\n",
    "---\n",
    "\n",
    "Las _tuplas_ son como una lista, pero inmutables.\n",
    "Si tiene datos que desea almacenar en una estructura, pero sabe que no se cambiarán, las tuplas pueden ser más eficientes para su almacenamiento."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "tupla = (2, 3.4, \"March\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'March'"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tupla[2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Formative assessment 6\n",
    "\n",
    "What will happen if we run the following lines of code? \n",
    "\n",
    "---\n",
    "\n",
    "¿Qué pasá si ejecutamos las siguientes lineas de código?\n",
    "```python\n",
    "tupla = (2, 3.4, \"March\")\n",
    "tupla.append(\"September\")\n",
    "print(tupla)\n",
    "```\n",
    "\n",
    "1. Return an error | Devuelve un error\n",
    "\n",
    "2. Return the tuple with a new element | Devuelve la tupla con un nuevo elemento:\n",
    "```\n",
    "(2, 3.4, \"March\", \"September\")\n",
    "```\n",
    "\n",
    "3. Return the same tuple | Devuelve la misma tupla: \n",
    "```\n",
    "(2, 3.4, \"March\")\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'tuple' object has no attribute 'append'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "Input \u001b[0;32mIn [47]\u001b[0m, in \u001b[0;36m<cell line: 3>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[38;5;66;03m# Solution | Solución\u001b[39;00m\n\u001b[0;32m----> 3\u001b[0m \u001b[43mtupla\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mappend\u001b[49m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mSeptember\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n",
      "\u001b[0;31mAttributeError\u001b[0m: 'tuple' object has no attribute 'append'"
     ]
    }
   ],
   "source": [
    "# Solution | Solución\n",
    "\n",
    "tupla.append(\"September\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "can only concatenate tuple (not \"str\") to tuple",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Input \u001b[0;32mIn [48]\u001b[0m, in \u001b[0;36m<cell line: 1>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mtupla\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43m \u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mseptember\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\n",
      "\u001b[0;31mTypeError\u001b[0m: can only concatenate tuple (not \"str\") to tuple"
     ]
    }
   ],
   "source": [
    "tupla + (\"september\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we want to add a new element in a tuple, we have to redefine the tuple: | Si queremos agregar un elemento nuevo a la tupla, tenemos que redefinir la tupla:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 3.4, 'March', 'September')"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tupla = (2, 3.4, \"March\", \"September\")\n",
    "tupla"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Dictionary | Diccionario\n",
    "\n",
    "_Dictionaries_ are a way to efficiently store and retrieve data values by a _keyword_.\n",
    "A dictionary is formed of key-value pairs, separated by commas, enclosed in curly brackets `{}`.\n",
    "The key and the value are separated by a colon `:`, i.e. `key: value`.\n",
    "\n",
    "---\n",
    "\n",
    "Los diccionarios nos permiten almacenar cualquier tipo de datos identificándolos por una _palabra clave_.\n",
    "Un diccionario está formado por pares de valores y claves, separados por comas, encerrados entre corchetes `{}`.\n",
    "La clave y el valor están separados por dos puntos `:`, es decir, `clave: valor`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'numerical': 1, 'alphabetical': 'abc'}\n"
     ]
    }
   ],
   "source": [
    "my_dict = {'numerical' : 1, 'alphabetical': 'abc'}\n",
    "\n",
    "print(my_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can access values using the keys between square brackets. | Podemos acceder a los valores usando las claves entre corchetes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_dict['numerical']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'abc'"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_dict.get(\"alphabetical\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys(['numerical', 'alphabetical'])"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_dict.keys()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Keys are inmutable (i.e. can't be changed) but values can be updated. | Las claves son inmutables (es decir, no se pueden cambiar) pero los valores se pueden actualizar."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_dict['numerical'] = 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also add new key-value pairs. | También podemos agregar nuevos pares clave-valor."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'numerical': 5, 'alphabetical': 'abc', 'binary': 1010001}\n"
     ]
    }
   ],
   "source": [
    "my_dict['binary'] = 1010001\n",
    "\n",
    "print(my_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Python Libraries | Librerías de Python\n",
    "\n",
    "One of the advantages of using Python to process data is the ability to use libraries.\n",
    "Libraries are **collections of modules** that contain functions to be used by other programs (for example, our notebooks and scripts). \n",
    "These functions usually save us a lot of time when performing certain tasks, since we do not need to write our own code to carry them out.\n",
    "\n",
    "In addition, libraries are usually developed following best practices:\n",
    "* Well designed code.\n",
    "* They use version control.\n",
    "* They have automated tests.\n",
    "* Extensive documentation.\n",
    "* Developed by a community.\n",
    "\n",
    "We will use this opportunity to learn about **[NumPy](https://numpy.org/)**, which is one of the most used libraries in scientific computing. \n",
    "\n",
    "----\n",
    "\n",
    "Una de las ventajas de usar Python para procesar datos es la posibilidad de usar librerías. \n",
    "Las librerías son **colecciones de módulos** que contienen funciones para ser usadas por otros programas (por ejemplo, nuestros notebooks y scripts).\n",
    "Estas funciones suelen ahorrarnos mucho tiempo a la hora de realizar determinadas tareas, ya que no necesitamos escribir nuestro propio código para llevarlas a cabo.\n",
    "\n",
    "Además, las librerías suelen están desarrolladas siguiendo las mejores prácticas:\n",
    "* Código bien diseñado.\n",
    "* Utilizan controladores de versiones.\n",
    "* Poseen testeos automatizados.\n",
    "* Documentación extensiva.\n",
    "* Desarrolladas por una comunidad.\n",
    "\n",
    "En esta oportunidad vamos a explorar la librería de **[NumPy](https://numpy.org/)**, una de las más utilizadas a la hora de realizar computación científica."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Importing NumPy | Importando NumPy\n",
    "\n",
    "In order to use a library, we first need to import it. | Para poder hacer uso de las librerías, primero necesitamos importarlas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "id": "6aJg7_-_o_xw"
   },
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "IDjAU8Rro_xy"
   },
   "source": [
    "This allows us to access the modules and functions of the library. | Esto nos permite acceder a los módulos y funciones de la librería. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "id": "REieQiW7o_x1",
    "outputId": "30d6e2e5-0747-4201-fbf3-c30a3f6f270a"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4])"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.array([1, 2, 3, 4])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "v_Vbal7Xo_x4"
   },
   "source": [
    "#### NumPy Arrays\n",
    "\n",
    "NumPy introduces a new type of variable, the `numpy.array`.\n",
    "Like lists, they allow you to store many values under a single variable:\n",
    "\n",
    "---\n",
    "\n",
    "NumPy introduce un nuevo tipo de variable, los `numpy.arrays` (o arreglos, en español).\n",
    "Al igual que las listas, permiten guardar muchos valores bajo una única variable:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "id": "KjdrXUPPo_x5"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2.  4.  6.  8.3 4.  5. ]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "numpy.ndarray"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array_1d = np.array([2, 4, 6, 8.3, 4, 5])\n",
    "\n",
    "print(array_1d)\n",
    "\n",
    "type(array_1d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "hPfcrHBmo_x7"
   },
   "source": [
    "We can use indexes as we did with lists. | Podemos usar los índices como lo hacíamos con las listas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "id": "OuB4PQT8o_x7",
    "outputId": "b95b59c4-bb1b-48bc-c5b9-bede10228b5a"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.0"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array_1d[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "id": "Y4Be8SYko_x8",
    "outputId": "9f8cd0d0-944e-4b98-9c68-220fffc424ad"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([6. , 8.3, 4. , 5. ])"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array_1d[2:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**What are the advantages and disadvantages of using `arrays`?** | **¿Cuáles son las ventajas y desventajas de usar `arrays`?**\n",
    "\n",
    "* Arrays have a **fixed size**. Once created, we cannot add or remove values from it.\n",
    "* Arrays **store a single type of variables** (floats or ints).\n",
    "* They have a **more efficient** management of memory.\n",
    "* All the **operations** we perform with _NumPy_ **are faster** than using _loops_ and _lists_.\n",
    "\n",
    "----\n",
    "\n",
    "* Los arrays **tienen tamaño fijo**. Una vez creados, no le podemos agregar o quitar valores.\n",
    "* Los arrays **almacenan un único tipo de variables** (floats o ints).\n",
    "* Tienen un **manejo mas eficiente** de la memoria.\n",
    "* Todas **las operaciones** que realicemos con _NumPy_ **son más rápidas** que usar _loops_ y _listas_."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Array operations | Operaciones con arrays\n",
    "\n",
    "Another advantage of using arrays is that many mathematical operations can be performed very easily.\n",
    "For example, let's go back to the values of distance in inches.\n",
    "\n",
    "----\n",
    "\n",
    "Otra ventaja de usar arrays es que muchas operaciones matemáticas pueden realizarse muy fácilmente.\n",
    "Por ejemplo, retomemos los valores de distancia medidas en pulgadas\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10.   24.5  90.    6.75 90.7  80.  ]\n"
     ]
    }
   ],
   "source": [
    "inches = [10, 24.5, 90, 6.75, 90.7, 80]\n",
    "\n",
    "# Convert the list into an array | Convertimos la lista en un array:\n",
    "inches = np.array(inches)\n",
    "\n",
    "print(inches)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Convert to meters: | Convertimos a metros:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.254   0.6223  2.286   0.17145 2.30378 2.032  ]\n"
     ]
    }
   ],
   "source": [
    "meters = inches * 25.4e-3 \n",
    "\n",
    "print(meters)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Add 10 meters: | Le sumo 10 metros:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([10.254  , 10.6223 , 12.286  , 10.17145, 12.30378, 12.032  ])"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "meters + 10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is also possible to operate with other arrays as long as they have the same shape. | También es posible operar con otros arreglos siempre y cuando tengan la misma forma."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[100. 200. 120.  98.  65.   3.] [2 1 3 4 9 5]\n"
     ]
    }
   ],
   "source": [
    "precios = np.array([100, 200, 120, 98, 65, 3], dtype=float)\n",
    "\n",
    "cantidades = np.array([2, 1, 3, 4, 9, 5])\n",
    "\n",
    "print(precios, cantidades)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[200. 200. 360. 392. 585.  15.]\n"
     ]
    }
   ],
   "source": [
    "costos = precios * cantidades\n",
    "\n",
    "print(costos)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1752.0\n"
     ]
    }
   ],
   "source": [
    "total = np.sum(costos)\n",
    "\n",
    "print(total)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Formative assessment 7 \n",
    "\n",
    "Given 2 arrays `a` and `b` that have different number of elements.\n",
    "What will happen if we add them?\n",
    "\n",
    "---\n",
    "\n",
    "Dados 2 arrays `a` y `b` que tiene diferente número de elementos. \n",
    "¿Qué pasará si los sumamos?:\n",
    "```python\n",
    "a = np.array([1, 2, 3])\n",
    "b = np.array([4, 5])\n",
    "\n",
    "a + b\n",
    "```\n",
    "\n",
    "\n",
    "1.  Add element by element and we get the following array | Suma elemento a elemento y obtenemos el siguiente array:\n",
    "```\n",
    "[5, 7, 3]\n",
    "```\n",
    "\n",
    "2. Concatenate the 2 arrays | Concatena los 2 arrays:\n",
    "```\n",
    "[1, 2, 3, 4, 5]\n",
    "```\n",
    "\n",
    "3. Return an error | obtenemos un error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "operands could not be broadcast together with shapes (3,) (2,) ",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "Input \u001b[0;32mIn [53]\u001b[0m, in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m a \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39marray([\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m2\u001b[39m, \u001b[38;5;241m3\u001b[39m])\n\u001b[1;32m      2\u001b[0m b \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39marray([\u001b[38;5;241m4\u001b[39m, \u001b[38;5;241m5\u001b[39m])\n\u001b[0;32m----> 4\u001b[0m \u001b[43ma\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mb\u001b[49m\n",
      "\u001b[0;31mValueError\u001b[0m: operands could not be broadcast together with shapes (3,) (2,) "
     ]
    }
   ],
   "source": [
    "a = np.array([1, 2, 3])\n",
    "b = np.array([4, 5])\n",
    "\n",
    "a + b\n",
    "\n",
    "# They have to have the same shape | Deben tener la misma forma"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Multidimensional arrays | Arrays multidimensional\n",
    "\n",
    "It is possible to define multidimensional arrays. \n",
    "For example, a 2D array would look like a matrix:\n",
    "\n",
    "----\n",
    "\n",
    "Es posible definir arreglos multidimensional.\n",
    "Por ejemplo, un arreglo 2D se vería como una matriz:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [4 5 6]]\n"
     ]
    }
   ],
   "source": [
    "array_2d = np.array([[1, 2, 3], [4, 5, 6]])\n",
    "\n",
    "print(array_2d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 3)"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array_2d.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tuple"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(array_2d.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can access each element of a 2D array through its indices. | Podemos acceder a cada elemento de un arreglo 2D a través de sus índices:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array_2d[0, 1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can extract a portion of the array. | Podemos extraer una porción del array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 5])"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array_2d[:, 1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Some NumPy functions | Algunas funciones de NumPy\n",
    "\n",
    "Every time we make use of the functions of a library, it is advisable to read its documentation\n",
    "\n",
    "---\n",
    "\n",
    "Cada vez que hagamos uso de las funciones de una librería, es recomendable leer su documentación."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[0;31mSignature:\u001b[0m\n",
       "\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmean\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\u001b[0m\n",
       "\u001b[0;34m\u001b[0m    \u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
       "\u001b[0;34m\u001b[0m    \u001b[0maxis\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
       "\u001b[0;34m\u001b[0m    \u001b[0mdtype\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
       "\u001b[0;34m\u001b[0m    \u001b[0mout\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
       "\u001b[0;34m\u001b[0m    \u001b[0mkeepdims\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m<\u001b[0m\u001b[0mno\u001b[0m \u001b[0mvalue\u001b[0m\u001b[0;34m>\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
       "\u001b[0;34m\u001b[0m    \u001b[0;34m*\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
       "\u001b[0;34m\u001b[0m    \u001b[0mwhere\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m<\u001b[0m\u001b[0mno\u001b[0m \u001b[0mvalue\u001b[0m\u001b[0;34m>\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n",
       "\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;31mDocstring:\u001b[0m\n",
       "Compute the arithmetic mean along the specified axis.\n",
       "\n",
       "Returns the average of the array elements.  The average is taken over\n",
       "the flattened array by default, otherwise over the specified axis.\n",
       "`float64` intermediate and return values are used for integer inputs.\n",
       "\n",
       "Parameters\n",
       "----------\n",
       "a : array_like\n",
       "    Array containing numbers whose mean is desired. If `a` is not an\n",
       "    array, a conversion is attempted.\n",
       "axis : None or int or tuple of ints, optional\n",
       "    Axis or axes along which the means are computed. The default is to\n",
       "    compute the mean of the flattened array.\n",
       "\n",
       "    .. versionadded:: 1.7.0\n",
       "\n",
       "    If this is a tuple of ints, a mean is performed over multiple axes,\n",
       "    instead of a single axis or all the axes as before.\n",
       "dtype : data-type, optional\n",
       "    Type to use in computing the mean.  For integer inputs, the default\n",
       "    is `float64`; for floating point inputs, it is the same as the\n",
       "    input dtype.\n",
       "out : ndarray, optional\n",
       "    Alternate output array in which to place the result.  The default\n",
       "    is ``None``; if provided, it must have the same shape as the\n",
       "    expected output, but the type will be cast if necessary.\n",
       "    See :ref:`ufuncs-output-type` for more details.\n",
       "\n",
       "keepdims : bool, optional\n",
       "    If this is set to True, the axes which are reduced are left\n",
       "    in the result as dimensions with size one. With this option,\n",
       "    the result will broadcast correctly against the input array.\n",
       "\n",
       "    If the default value is passed, then `keepdims` will not be\n",
       "    passed through to the `mean` method of sub-classes of\n",
       "    `ndarray`, however any non-default value will be.  If the\n",
       "    sub-class' method does not implement `keepdims` any\n",
       "    exceptions will be raised.\n",
       "\n",
       "where : array_like of bool, optional\n",
       "    Elements to include in the mean. See `~numpy.ufunc.reduce` for details.\n",
       "\n",
       "    .. versionadded:: 1.20.0\n",
       "\n",
       "Returns\n",
       "-------\n",
       "m : ndarray, see dtype parameter above\n",
       "    If `out=None`, returns a new array containing the mean values,\n",
       "    otherwise a reference to the output array is returned.\n",
       "\n",
       "See Also\n",
       "--------\n",
       "average : Weighted average\n",
       "std, var, nanmean, nanstd, nanvar\n",
       "\n",
       "Notes\n",
       "-----\n",
       "The arithmetic mean is the sum of the elements along the axis divided\n",
       "by the number of elements.\n",
       "\n",
       "Note that for floating-point input, the mean is computed using the\n",
       "same precision the input has.  Depending on the input data, this can\n",
       "cause the results to be inaccurate, especially for `float32` (see\n",
       "example below).  Specifying a higher-precision accumulator using the\n",
       "`dtype` keyword can alleviate this issue.\n",
       "\n",
       "By default, `float16` results are computed using `float32` intermediates\n",
       "for extra precision.\n",
       "\n",
       "Examples\n",
       "--------\n",
       ">>> a = np.array([[1, 2], [3, 4]])\n",
       ">>> np.mean(a)\n",
       "2.5\n",
       ">>> np.mean(a, axis=0)\n",
       "array([2., 3.])\n",
       ">>> np.mean(a, axis=1)\n",
       "array([1.5, 3.5])\n",
       "\n",
       "In single precision, `mean` can be inaccurate:\n",
       "\n",
       ">>> a = np.zeros((2, 512*512), dtype=np.float32)\n",
       ">>> a[0, :] = 1.0\n",
       ">>> a[1, :] = 0.1\n",
       ">>> np.mean(a)\n",
       "0.54999924\n",
       "\n",
       "Computing the mean in float64 is more accurate:\n",
       "\n",
       ">>> np.mean(a, dtype=np.float64)\n",
       "0.55000000074505806 # may vary\n",
       "\n",
       "Specifying a where argument:\n",
       ">>> a = np.array([[5, 9, 13], [14, 10, 12], [11, 15, 19]])\n",
       ">>> np.mean(a)\n",
       "12.0\n",
       ">>> np.mean(a, where=[[True], [False], [False]])\n",
       "9.0\n",
       "\u001b[0;31mFile:\u001b[0m      ~/.mambaforge/envs/default/lib/python3.9/site-packages/numpy/core/fromnumeric.py\n",
       "\u001b[0;31mType:\u001b[0m      function\n"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "np.mean?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2.  4.  6.  8.3 4.  5. ]\n",
      "Mean: 4.883333333333334 Standard deviation: 1.9497150788997066 Max: 8.3 Min: 2.0 Square root: [1.41421356 2.         2.44948974 2.88097206 2.         2.23606798]\n"
     ]
    }
   ],
   "source": [
    "print(array_1d)\n",
    "\n",
    "print(\n",
    "    \"Mean:\", np.mean(array_1d),\n",
    "    \"Standard deviation:\", np.std(array_1d),\n",
    "    \"Max:\", np.max(array_1d),\n",
    "    \"Min:\", np.min(array_1d),\n",
    "    \"Square root:\", np.sqrt(array_1d)\n",
    "     )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Homework | Tarea\n",
    "\n",
    "Before doing your homework, _check_ that you have a _local repository_ called `coco_coding_homework`.\n",
    "If you don't have it, create this repository according to what you learned in the _Git session_.\n",
    "In this repository you will push all the notebooks with the solution of the proposed activities.\n",
    "\n",
    "Then, _create a notebook_ called `homework_python_basics.ipynb` into the _local repository_.\n",
    "There you will solve the activities proposed below.\n",
    "After _commit_ your notebook's changes, _push_ them into the _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, _verifique_ que tiene creado un repositorio local nombre `coco_coding_homework`. \n",
    "Si no lo tiene, cree el repositorio según lo aprendido en la _sesión de Git_.\n",
    "En este repositorio subirá todos los notebooks con la solución de las actividades propuestas.\n",
    "\n",
    "Luego _cree un notebook_ llamado `homework_python_basics.ipynb` en el _repositorio local_.\n",
    "Alli es donde resolverá las actividades propuestas a continuación.\n",
    "Luego de hacer un _commit_ a los cambios que hizo en el notebook, haga un _push_ para subir los cambias al _repositorio remoto_ en sucuenta de GitHub. \n",
    "De esta forma, alguno de los trainers podrá ver sus respuestas y darle una devolución de las actividades resueltas. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true,
    "tags": []
   },
   "source": [
    "#### 1° Task\n",
    "\n",
    "1. Create a list with the names of every planet in the solar system (in order)\n",
    "2. Have Python tell you how many planets there are by examining your list\n",
    "3. Print the first four planets in the solar system (the rocky planets)\n",
    "4. Print the planet if it has an s at the end in its name\n",
    "\n",
    "---\n",
    "\n",
    "1. Crea una lista con los nombres de todos los planetas del sistema solar (en orden)\n",
    "2. Haz que Python te diga cuántos planetas hay examinando tu lista\n",
    "3. Muestre los primeros cuatro planetas  del sistema solar (los planetas rocosos)\n",
    "4. Imprimir el nombre del planeta que tiene una s al final de su nombre"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true,
    "tags": []
   },
   "source": [
    "#### 2° Task\n",
    "\n",
    "A colleague from the United States shared with us the following temperature measurement, given in Fahrenheit:\n",
    "\n",
    "$$\n",
    "T = 30.3^\\circ \\text{F}\n",
    "$$\n",
    "\n",
    "Convert this value to degrees Celsius, knowing that:\n",
    "$$[^\\circ \\text{C}] = \\frac{5}{9} ([^\\circ \\text{F}] - 32) $$ \n",
    "\n",
    "Requirements:\n",
    "\n",
    "* Assign the received data to a variable.\n",
    "* Apply the unit transformation using this variable.\n",
    "* Save the data in Celsius in another variable.\n",
    "* Use the print function to display both results.\n",
    "\n",
    "---\n",
    "\n",
    "Un colega de Estados Unidos nos ha compartido la siguiente medición de temperatura de suelo dada en Fahrenheit:\n",
    "$$ T = 30.3 ^\\circ\\text{F} $$\n",
    "\n",
    "Conviertan este valor a grados Celsius, sabiendo que:\n",
    "$$ [^\\circ\\text{C}] = \\frac{5}{9} ([^\\circ\\text{F}] - 32) $$\n",
    "\n",
    "Requerimientos:\n",
    "\n",
    "* Asignar el dato recibido a una variable.\n",
    "* Aplicar la transformación de unidades usando esta variable.\n",
    "* Guardar el dato en Celsius en otra variable.\n",
    "* Utilizar la función print para mostrar ambos resultados.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3° Task\n",
    "\n",
    "Given the array: `([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16])`, investigate the `numpy` library documentation for reshape the array to be 4x4.\n",
    "\n",
    "----\n",
    "\n",
    "Dado el array: `([ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16])` investigue la documentación de la librería `numpy` para \"reshape\" o reformular el array para que sea de 4x4.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 4° Task\n",
    "\n",
    "`NumPy` allows us to apply mathematical functions.\n",
    "\n",
    "Calculate the sine and cosine of the angles 0, 30, 45, 60 and 90 given in degrees:\n",
    "1. Create an array with the angles in degrees.\n",
    "2. Convert the angles to radians.\n",
    "3. Calculate the sine and cosine of these angles and store them in two different arrays.\n",
    "\n",
    "_Investigate the `numpy` library to find the functions to convert the angles from degrees to radians and calculate the sine and cosine._\n",
    "\n",
    "---\n",
    "\n",
    "`NumPy` nos permite también aplicar funciones matemáticas. \n",
    "\n",
    "Calcule el seno y el coseno de los ángulos: 0, 30, 45, 60 y 90 dados en grados:\n",
    "1. Cree un array con los ángulos mencionados en grados.\n",
    "2. Convierta los ángulos a radianes.\n",
    "3. Calcule el seno y el coseno de estos ángulos y guárdelos en dos arrays diferentes.\n",
    "\n",
    "_Investigue la librería `numpy` para encontrar las funciones que permitan convertir los ángulos en grados a radianes y calcular el seno y coseno._"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 5° Task\n",
    "\n",
    "\n",
    "**Finite differences | Diferencias finitas**\n",
    "\n",
    "A common approximation for computing derivatives of functions is a finite difference approximation:\n",
    "\n",
    "$$\\frac{d}{dx} y(x) = \\frac{y(x + \\Delta x) - y(x)}{\\Delta x}$$\n",
    "\n",
    "or for discrete data\n",
    "\n",
    "$$\\frac{d}{dx} y(x_i) = \\frac{y(x_i + \\Delta x) - y(x_i)}{\\Delta x} = \\frac{y(x_{i+1}) - y(x_i)}{x_{i+1} - x_{i}}$$\n",
    "\n",
    "This operation can be accomplished using index, slice and vectorized algebraic operations.\n",
    "Try to solve it for the quadratic function!\n",
    "\n",
    "Now, read the numpy documentation to find a function to calculate $\\frac{d}{dx} y(x_i)$.\n",
    "\n",
    "----\n",
    "\n",
    "Una aproximación común para calcular derivadas de funciones es una aproximación en diferencias finitas:\n",
    "\n",
    "$$\\frac{d}{dx} y(x) = \\frac{y(x + \\Delta x) - y(x)}{\\Delta x}$$\n",
    "\n",
    "o para datos discretos\n",
    "\n",
    "$$\\frac{d}{dx} y(x_i) = \\frac{y(x_i + \\Delta x) - y(x_i)}{\\Delta x} = \\frac{y(x_{i+1}) - y(x_i)}{x_{i+1} - x_{i}}$$\n",
    "\n",
    "Esta operación se puede realizar utilizando las operaciones algebraicas vectorizadas, indices y silce. \n",
    "¡Intenta calcularlo para la función cuadrática!\n",
    "\n",
    "Ahora, lea la documentación de Numpy para encontrar una función para poder calcular $\\frac{d}{dx} y(x_i)$. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Extra material to keep learning | Material extra para seguir aprendiendo\n",
    "\n",
    "* [How use JupyterLab by Software Carpentry](https://swcarpentry.github.io/python-novice-gapminder/01-run-quit/index.html)\n",
    "\n",
    "* [Apuntes generates de Python](https://drive.google.com/file/d/12_1yUhaGeoH7wLGqrHiSx987FMdqM_Mv/view)\n",
    "\n",
    "* [Introduction to Python1](https://johnfoster.pge.utexas.edu/numerical-methods-book/PythonIntro.html)\n",
    "\n",
    "* [Plotting and Programming in Python by Software Carpenty](https://swcarpentry.github.io/python-novice-gapminder/index.html)\n",
    "\n",
    "* [NumPy tutorials](https://numpy.org/learn/)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "colab": {
   "name": "Coco_Session2.ipynb",
   "provenance": []
  },
  "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.8.13"
  },
  "toc-autonumbering": true,
  "toc-showcode": false
 },
 "nbformat": 4,
 "nbformat_minor": 4
}