{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ¿Qué es programar?\n",
    "Un programa de ordenador es una serie de __instrucciones__ que le dicen a la máquina qué tiene que hacer. Las máquinas no entienden nuestro lenguaje, por lo que tenemos que aprender un lenguaje para poder comunicarnos con ellas y darles órdenes. Hay muchísimos lenguajes de programación hoy en día, cada lenguaje se usa para hacer un tipo de programa. Por ejemplo, si quieres hacer una página web puedes usar _HTML_, _CSS_ y _Javascript_, si quieres hacer un programa para consultar una base de datos puedes usar _SQL_. En el caso de __Python__, es un lenguaje usado para muchas cosas: desde hacer cálculos científicos hasta programación web, pasando por robótica, seguridad, ciencia de datos, física y muchísimas cosas más. Además, _Python_ es muy sencillo de entender y programar, ya que simplifica muchas tareas que en otros lenguajes como _C_ son muy tediosas. Por eso, es ideal para entender los conceptos básicos de programación y para iniciarse en este mundillo.\n",
    "\n",
    "\n",
    "# Hola mundo!\n",
    "Vamos a empezar a programar. El primer programa que se suele hacer en todos los lenguajes de programación es conocido como el _hola mundo_. En otros lenguajes como _C_, tendríamos que hacer varias líneas de código y, después, compilar nuestro programa para poder ejecutarlo, en cambio, en _Python_ lo podemos ejecutar en una sola línea!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## PARA EJECUTAR EL CODIGO EN LAS CELDAS DONDE PONE IN [ ], DALE AL SÍMBOLO DE **RUN** EN LA BARRA DE HERRAMIENTAS"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Hola mundo\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ahora imagina que quieres hacer un programa para saludar a tu amiga _Marta_, ¿cómo lo harías? De primeras, podrías hacer lo siguiente:"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "print(\"Hola Marta!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Así, tendríamos un programa para saludar a cualquier Marta del mundo, pero, ¿y si quisiéramos un programa para poder saludar a cualquier persona? Para poder llevar esto a cabo necesitamos introducir un concepto de programación básico: las __variables__.\n",
    "\n",
    "# Variables\n",
    "Una variable en programación describe un lugar donde guardar información, que puede ser diferente en cada ejecución. En nuestro caso, queremos saludar al usuario que ejecute nuestro programa, pero no sabemos su nombre a priori y no lo sabremos hasta la ejecución, por tanto, necesitamos reservar un espacio para poder guardar ahí el nombre del usuario durante la ejecución de nuestro programa.\n",
    "\n",
    "Hay muchos tipos de variables: \n",
    "\n",
    "* números enteros (`int`)\n",
    "* números reales (`float` o `double`)\n",
    "* caracteres (`char`) y cadenas de caracteres (`string`)\n",
    "* booleanos (`bool`), estos últimos sólo pueden tomar dos valores: verdadero (`True`) o falso (`False`).\n",
    "\n",
    "En otros lenguajes de programación, como _C_, necesitamos indicar el tipo que tiene cada variable que declaramos. En cambio, en python no es necesario ya que el propio intérprete lo infiere por sí mismo. \n",
    "\n",
    "Una vez hemos aprendido el concepto de variable, ya sí podemos hacer nuestro programa para saludar a cualquier persona."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nombre= input(\"Introduce tu nombre\")\n",
    "print (nombre)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Operando con variables\n",
    "\n",
    "En Python podemos hacer operaciones sobre las variables que tenemos de forma muy sencilla. A modo de resumen, las principales operaciones en python son:\n",
    "\n",
    "| Símbolo | Operación     |\n",
    "|:-------:|:-------------:|\n",
    "|+        | suma          |\n",
    "|-        | resta         |\n",
    "|*        | multiplicación|\n",
    "|/        | división      |\n",
    "\n",
    "Estos operadores se pueden usar con cualquier tipo de variable, tanto números como letras. A continuación, te muestro varios ejemplos.\n",
    "\n",
    "Podemos concatenar dos palabras usando el operador +."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "primerapalabra=\"PY\"\n",
    "segundapalabra=\"DAY\"\n",
    "print(primerapalabra+\"-\"+segundapalabra)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "También podemos multiplicar una palabra por un número usando el operador *."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "var=input(\"Cómo te llamas?\")\n",
    "print(var*5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Y por último, también podemos hacer operaciones numéricas. En las operaciones numéricas Python respeta el orden de los operadores: primero se realizan las multiplicaciones y divisiones y, después, las sumas y restas. Si queremos cambiar este orden simplemente tenemos que usar paréntesis."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "num2 = 6\n",
    "operacion1 = num1 + num2 * 2\n",
    "print(operacion1)\n",
    "operacion2 = (num1 + num2) * 2\n",
    "print(operacion2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En el primer caso hemos realizado la operación \n",
    "\n",
    "$$5 + (6 * 2) = 5 + 12 = 17$$\n",
    "\n",
    "y en el segundo, en cambio\n",
    "\n",
    "$$ (5 + 6) * 2 = 11 * 2 = 22$$\n",
    "\n",
    "### Ejercicio: \n",
    "\n",
    "__Haz un pequeño programa que le pida al usuario introducir dos números ($x_1$ y $x_2$), calcule la siguiente operación y muestre el resultado de la misma ($x$):__\n",
    "\n",
    "$$ x = \\frac{20 * x_1 - x_2}{x_2 + 3} $$\n",
    "\n",
    "__Si intentas operar con el resultado de la función `input` obtendrás un error que te informa que no se pueden restar dos datos de tipo `str`. Usa la función `int` para convertir los datos introducidos por teclado a datos numéricos.__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x1= input(\"Introduce la variable x1\")\n",
    "x2= input (\"Introduce la variable x2\")\n",
    "x1=int(x1)\n",
    "x2=int(x2)\n",
    "x=((20*x1)-x2)/(x2+3)\n",
    "print(\"El resultado es: \", x)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Librería `math`\n",
    "\n",
    "Una __librería__ es un conjunto de operaciones relacionadas entre sí, guardadas en una especie de \"paquete\". En este caso, vamos a hablar de la librería `math` que tiene operaciones matemáticas más avanzadas tales como la raíz cuadrada.\n",
    "\n",
    "Para poder usar esta librería debemos importarla a nuestro programa. Esto se hace usando la instrucción `import`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math as matematicas\n",
    "x=matematicas.sqrt()\n",
    "x=int(x)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Usando sólo la instrucción `import` debemos preceder la instrucción que queremos del nombre de la librería. Si este nombre es muy largo, podemos importar la librería usando un alias:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math as m\n",
    "\n",
    "print(m.sqrt(4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ahora bien, si sólo vamos a usar unas operaciones concretas de una librería, podemos especificar cuáles son y así no tener que usar el nombre de la librería para poder utilizarlas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import sqrt\n",
    "\n",
    "print(sqrt(4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Esta librería tiene muchas más operaciones que puedes consultar en la [documentación oficial](https://docs.python.org/3/library/math.html)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Estructuras de control\n",
    "\n",
    "Hasta ahora, nuestros programas se basan en una serie de instrucciones que se ejecutan una detrás de otra. Esto limita mucho los programas que podemos hacer, ya que no nos permite controlar el __flujo de ejecución__ (_control flow_) de nuestro programa. A continuación vamos a ver una serie de instrucciones especiales que nos permiten hacer precisamente eso.\n",
    "\n",
    "## `if`\n",
    "\n",
    "Imagina que estás operando con raíces cuadradas, como sabrás la raíz cuadrada de un número es negativa, y quieres evitar hacer la raíz cuadrada si el número introducido por el usuario es negativo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "num = int(input(\"Introduce un número: \"))\n",
    "raiz = sqrt(num)\n",
    "print (raiz)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "¿Qué podemos hacer para que no ocurra esto? Controlar con un `if` la __condición__ de que el número sea positivo para hacer la raíz cuadrada y avisar al usuario en caso contrario:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "num = int(input(\"Introduce un número: \"))\n",
    "if num > 0:\n",
    "    raiz = sqrt(num)\n",
    "else:\n",
    "    print(\"No puedo hacer la raíz de un número negativo!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si quisiéramos controlar una condición más, usaríamos la instrucción `elif`, que en otros lenguajes como C es conocida como `else if`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if num > 0:\n",
    "    raiz = sqrt(num)\n",
    "elif num == 0:\n",
    "    print(\"Para qué quieres saber eso jaja saludos\")\n",
    "else:\n",
    "    print(\"No puedo hacer la raíz de un número negativo!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ejercicio\n",
    "\n",
    "__Haz un programa que le pida al usuario un número (de ninjas). Si dicho número es menor que 50 y es par, el programa imprimirá \"puedo con ellos!\", en caso contrario imprimirá \"no me vendría mal una ayudita...\"__\n",
    "\n",
    "Nota: para saber si un número es par o no debes usar el operador $\\%$ y para saber si dos condiciones se cuplen a la vez, el operador lógico `and`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# `while`\n",
    "\n",
    "En el ejemplo anterior le decíamos al usuario que no podíamos hacer la raíz negativa de un número pero, ¿cómo haríamos para, en vez de darle este mensaje, volver a pedirle un número una y otra vez hasta que fuese negativo? Necesitamos ejecutar el mismo código hasta que se dé la condición que buscamos: que el usuario introduzca un número positivo.\n",
    "\n",
    "Esto podemos hacerlo usando un __bucle `while`__! "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "num = int(input(\"Introduce un número: \"))\n",
    "\n",
    "while (num < 0):\n",
    "    num = int(input(\"Introduce un número: \"))\n",
    "\n",
    "raiz = sqrt(num)\n",
    "print(raiz)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ejercicio\n",
    "\n",
    "__Haz un bucle `while` que imprima todos los números desde el 0 hasta un número que introduzca el usuario. Si el número que introduce es negativo puedes tomar dos decisiones: pedirle que introduzca un número positivo o contar hacia atrás, tú eliges!__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `for`\n",
    "\n",
    "En lenguajes de programación como C o Java, un bucle `for` sirve para recorrer una secuencia de números, de la siguiente forma:\n",
    "\n",
    "```\n",
    "for (int i=0; i<maximo_numero; i++)\n",
    "```\n",
    "\n",
    "Donde `maximo_numero` es una variable previamente definida. \n",
    "\n",
    "Hay también otro tipo de bucles for denominados `forEach` en Java que sirven para iterar sobre los elementos de cualquier estructura de datos (más adelante veremos lo que es). En Python, los bucles `for` tienen esta función: iterar sobre una serie de elementos. \n",
    "\n",
    "Para iterar sobre una serie de números, debemos generar dicha serie usando la función `range()`. Así, el ejercicio anteriormente pleanteado para resolverse con un bucle `while` sería:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(num):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "¿Qué es eso de la función `range()`? Sirve para generar una secuencia de números. Puedes consultar más sobre esta función en la [documentación de Python](https://docs.python.org/3.7/library/stdtypes.html#range). En Python 2, existían tanto `range` como `xrange` aunque en Python 3, `range` hace lo mismo que hacía `xrange` en Python 2.\n",
    "\n",
    "### Ejercicio\n",
    "\n",
    "__Genera con `range` los números pares del 0 al 10, ambos inclusive. ¿Qué cambiarías para generar del 2 al 10?__\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `break`\n",
    "\n",
    "La sentencia `break` sirve para detener un bucle antes de que llegue al final (en un bucle `for`) o antes de que la condición sea falsa (en un bucle `while`). \n",
    "\n",
    "Los bucles (`for` y `while`) pueden tener una sentencia `else` como los `if`. Esta sentencia `else` se ejecuta si el bucle __no__ ha terminado por un `break` y nos puede servir para controlar cuando un bucle termina o no debido a un `break` de forma sencilla.\n",
    "\n",
    "El código siguiente refleja muy bien esto: para saber si un número $n$ es primo calculamos su módulo entre todos los números en el intervalo $[2,n)$ y, en el momento en el que uno de estos módulos sea igual a $0$, sabremos que $n$ no es primo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for n in range(2,10):\n",
    "    for x in range(2, n):\n",
    "        if n % x == 0:\n",
    "            print(n, \" = \", x, \" * \", n//x)\n",
    "            break\n",
    "    else:\n",
    "        print(n, \" es primo!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cuando $n \\% x = 0$, dejamos de hacer módulos con $n$ pues ya sabemos que __no__ es primo. Por tanto, nos salimos del bucle con un `break`. Al salirnos con el `break`, no entramos en el `else` sino que volvemos al bucle inicial. En cambio, no hemos encontrado ningún $x$ tal que $n \\% x = 0$, ejecutamos la condición `else` para decir que $n$ es primo.\n",
    "\n",
    "### Ejercicio\n",
    "\n",
    "__¿Cuál es la diferencia entre la sentencia `break` y la sentencia `continue`?__\n",
    "\n",
    "Pista: consúltalo en la [documentación de Python](https://docs.python.org/3.6/tutorial/controlflow.html#break-and-continue-statements-and-else-clauses-on-loops)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Estructuras de datos\n",
    "Por ahora sólo hemos estudiado variables en las que podemos guardar un único valor: un número, una letra, una frase... ¿No te da la impresión de que esto se queda algo corto? Sí, y probablemente no eres la única persona que lo ha pensado. Las __estructuras de datos__ son variables compuestas, esto quiere decir que en ellas podemos almacenar muchos datos. Hay estructuras de datos de todo tipo, en python tenemos las siguientes:\n",
    "\n",
    "* __Listas__\n",
    "* __Tuplas__\n",
    "* __Conjuntos__\n",
    "* __Diccionarios__\n",
    "\n",
    "## Listas\n",
    "Imagina que quieres guardar en una variable los nombres de tus mejores amigos. Una muy buena opción para hacerlo es una lista. Al igual que en la vida real hacemos listas como _lista de cosas por hacer_, _lista para la compra_, _lista de propósitos de año nuevo_, etc. en Python también podemos hacerlas usando esta estructura de datos.\n",
    "\n",
    "Con las listas, podemos guardar en un mismo sitio variables relacionadas entre sí. Esto nos permite poder aplicar operaciones sobre todas ellas sin tener que repetir código. \n",
    "\n",
    "Para declarar una lista, usaremos los []."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mis_amigos = ['Paloma', 'Paula', 'Teresa', 'Marina', 'Braulio']\n",
    "print(mis_amigos)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Al imprimir la lista vemos los diferentes elementos que contiene. Pero, ¿y si queremos acceder a sólo uno de los elementos? En ese caso, necesitarás acceder mediante __índices__. Cada elemento de la lista tiene un número asociado con su posición dentro de la misma:\n",
    "\n",
    "| Elemento | Posición |\n",
    "|:--------:|:--------:|\n",
    "|Paloma    | 0        |\n",
    "|Paula     | 1        |\n",
    "|Teresa    | 2        |\n",
    "|Marina    | 3        |\n",
    "|Braulio   | 4        |\n",
    "\n",
    "así, si por ejemplo queremos únicamente mostrar a nuestro mejor amigo, accederemos a él mediante el índice 0:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mis_amigos[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si intentamos acceder a un índice superior al último de todos, 4, obtendremos un error:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mis_amigos[5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Entonces, uno podría pensar que está _obligado_ a conocer la longitud de la lista si quiere acceder al último elemento pero nada más lejos de la realidad! En python, también existen los índices inversos que nos permiten acceder a los elementos de la lista al revés:\n",
    "\n",
    "| Elemento | Posición |\n",
    "|:--------:|:--------:|\n",
    "|Paloma    | -5       |\n",
    "|Paula     | -4       |\n",
    "|Teresa    | -3       |\n",
    "|Marina    | -2       |\n",
    "|Braulio   | -1       |\n",
    "\n",
    "Por lo que para acceder al último elemento de nuestra lista sólo tendríamos que usar el índice -1:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mis_amigos[-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Otra cosa que nos podemos hacer usando índices es quedarnos con una sublista. Por ejemplo, si quisiéramos quedarnos únicamente con un top 3 de amigos guays podríamos hacerlo usando el operador :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mis_amigos[0:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pero si queremos quedarnos con los tres primeros, podemos simplemente hacerlo de la siguiente forma:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mis_amigos[:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "¿Y si queremos saber el resto? Simplemente, lo hacemos al revés!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mis_amigos[3:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ejercicio:\n",
    "__Haz una lista de la compra e imprime los siguientes elementos__:\n",
    "\n",
    "* __Penúltimo elemento__\n",
    "* __Del segundo al cuarto elemento__\n",
    "* __Los tres últimos__\n",
    "* __Todos!__\n",
    "\n",
    "\n",
    "__Por último, elimina el tercer elemento de la lista usando la sentencia `del`__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Iterando sobre una lista\n",
    "\n",
    "Con los bucles podemos iterar sobre los valores de una lista. Típicamente, un programador C iteraría sobre una lista de la siguiente forma:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(len(mis_amigos)):\n",
    "    print(mis_amigos[i])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ahora bien, en Python existe una forma mucho más cómoda de iterar sobre los valores de una lista sin tener que estar pendiente de un índice `i`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for amigo in mis_amigos:\n",
    "    print(amigo)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En Python también existe lo que se llama __list comprehesions__, que son una forma mucho más sencilla y fácil de leer para crear listas. Por ejemplo, si queremos hacer una lista con las potencias de 2, podríamos hacerlo de la siguiente forma:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "potencias = []\n",
    "for x in range(10):\n",
    "    potencias.append(2**x)\n",
    "\n",
    "print(potencias)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tendríamos nuestra lista de potencias de 2 en tres líneas, pero con los __list comprehesions__ podemos hacerlo en una única línea:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "potencias = [x**2 for x in range(10)]\n",
    "print(potencias)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ejercicio\n",
    "\n",
    "__Crea una lista con todos los números pares del 0 al 10 en una única línea.__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Listas anidadas\n",
    "\n",
    "Seguramente te habrás preguntado si se puede hacer una lista cuyos elementos sean listas, y la respuesta es ¡sí!. Esta representación de listas anidadas se suele usar para representar matrices. Por ejemplo, si queremos representar la siguiente matriz en Python:\n",
    "\n",
    "$$ M_{2 \\times 3} = \\left ( \\begin{matrix}\n",
    "1 & 2 & 3 \\\\\n",
    "2 & 3 & 4 \n",
    "\\end{matrix} \\right)$$\n",
    "\n",
    "Lo haríamos de la siguiente forma:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "M = [[j for j in range(i, i+3)] for i in range(1,3)]\n",
    "M"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ejercicio\n",
    "\n",
    "__Crea la siguiente matriz en una línea:__\n",
    "\n",
    "$$ M_{2 \\times 3} = \\left ( \\begin{matrix}\n",
    "1 & 2 & 3 \\\\\n",
    "4 & 5 & 6 \n",
    "\\end{matrix} \\right)$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tuplas\n",
    "\n",
    "Imagina que deseas guardar tanto los nombres de tus mejores amigos como su edad. De primeras podrías pensar en hacer dos listas, de la siguiente forma:\n",
    "\n",
    "| índice | 0 | 1 | 2 | 3 | 4 |\n",
    "|:------:|:-:|:-:|:-:|:-:|:-:|\n",
    "| nombres| Paloma | Paula | Teresa | Marina | Braulio |\n",
    "| edades | 25 | 20 | 19 | 19 | 21 |\n",
    "\n",
    "De tal forma que para saber la edad de Paloma (primer elemento de la lista `nombres`) tendríamos que mirar el primer elemento de la lista `edades`. Pero, ¿y si te dijera que en Python podríamos guardar en una misma variable la edad y el nombre de una persona? Se puede! Con las llamadas __tuplas__.\n",
    "\n",
    "Una __tupla__ es una serie de valores separados por comas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tupla_ejemplo = 5, 'perro', 3.6\n",
    "print(tupla_ejemplo)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Por tanto, para guardar en una lista tanto el nombre como la edad de nuestros amigos podríamos hacerlo de la siguiente forma:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "amigos_edades = [('Paloma', 25), ('Paula', 20), ('Teresa', 19), ('Marina', 19), ('Braulio', 21)]\n",
    "print(amigos_edades)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Los valores de las tuplas también tienen índices, por tanto, en nuestro caso el nombre tendría el índice 0 y la edad el índice 1. Por tanto, si queremos acceder a la edad de _Paloma_ tenemos que usar el operador `[]` dos veces: una para acceder al elemento de la lista que queremos y otra para acceder al elemento de la tupla que queremos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "amigos_edades[0][1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si queremos crear dos variables separadas para guardar el nombre y la edad de nuestro mejor amigo, podemos hacerlo en una sola línea!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nombre, edad = amigos_edades[0]\n",
    "\n",
    "print(nombre)\n",
    "print(edad)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cuidado! Si por casualidad un amigo cumpliese un año más no podríamos ponerlo en la tupla, debido a que __las tuplas no pueden modificarse__."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "amigos_edades[0][1] += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ejercicio:\n",
    "__Vuelve a hacer la lista de la compra que hiciste en el último ejercicio, pero esta vez guarda cada elemento de la lista de la compra junto con su precio. Después, imprime los siguientes elementos:__\n",
    "\n",
    "* __El precio del tercer elemento.__\n",
    "* __El nombre del último elemento.__\n",
    "* __Tanto el nombre como el precio del primer elemento__."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Cojuntos\n",
    "\n",
    "Un conjunto es una lista de elementos ordenados y en la que no hay elementos repetidos. Se definen con el operador `{`. Sus operadores básicos son eliminar elementos repetidos, consultar si un elemento está en el conjunto o no y, por supuesto, operaciones típicas de los conjuntos como la unión, la intersección, la diferencia...\n",
    "\n",
    "¿Qué ventajas puede darte usar un conjunto en lugar de una lista? Al estar ordenados, es mucho más rápido encontrar un elemento aunque esto también hace que insertar nuevos elementos sea más costoso.\n",
    "\n",
    "Podemos crear un conjunto a partir de una lista:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mi_lista = [5,4,6,3,7,5,1,9,3]\n",
    "print(mi_lista)\n",
    "mi_conjunto = set(mi_lista)\n",
    "print(mi_conjunto)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Además, podemos hacer las operaciones típicas sobre conjuntos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = {1,2,4,5,6,7}\n",
    "B = {2,3,5,6,8,9}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Elementos de A que no están en B (diferencia):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A - B"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Elementos que están o bien en A o bien en B (unión):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A | B"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Elementos que están tanto en A como en B (intersección):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A & B"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Elementos que están en A o en B pero no en ambos (diferencia simétrica):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A ^ B"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "¿Podríamos hacer un conjunto de listas?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "{[1,2,3],[4,5,6]}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "¡No! Esto es debido a que __los elementos de los conjuntos deben ser _hashables___. Tal y como se explica en la [documentación](https://docs.python.org/3.6/glossary.html), un objeto es _hashable_ si su clase define la función `__hash__()`, que calcula un entero para caracterizar a un objeto, por lo que objetos con el mismo valor deben tener el mismo entero hash, y la función `__eq__()`, que sirve para comparar objetos.\n",
    "\n",
    "Las estructuras de datos que pueden cambiar su valor, como las listas o los diccionarios, no son hashables y, por lo tanto, no pueden ser elementos de un conjunto."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Iterando sobre conjuntos\n",
    "\n",
    "Al igual que con las listas, también es posible iterar sobre conjuntos y hacer __set comprehesions__:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "{x for x in 'abracadabra' if x not in 'abc'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for c in mi_conjunto:\n",
    "    print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ejercicio\n",
    "\n",
    "__¿Es buena idea usar la función `set` para eliminar los elementos repetidos de una lista?__ "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Un último detalle sobre conjuntos: para crear un conjunto vacío usamos `set()` ya que usar `{}` creará un diccionario vacío.\n",
    "\n",
    "## Diccionarios\n",
    "A diferencia de las estructuras de datos que hemos visto hasta ahora, los diccionarios no se indexan por números sino por ___claves___ (_keys_). Cada entrada de nuestro diccionario está formada por dos valores distintos: la clave y el valor. La clave nos sirve para acceder al elemento (valor) de forma rápida. Debido a que las claves sirven para identificar a cada elemento,deben ser únicas: si introduces un nuevo elemento en el diccionario con clave repetida, __se sobreescribirá el elemento anterior__ así que ¡mucho cuidado!\n",
    "\n",
    "Vamos a ver un pequeño ejemplo de uso de los diccionarios para que nos quede más claro. Volvamos al ejemplo anterior sobre nuestros amigos y su edad."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mis_amigos = {'Paloma':25, 'Paula':20, 'Teresa':19, 'Marina':19, \n",
    "              'Braulio':21}\n",
    "print(mis_amigos)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para obtener la edad de _Paloma_, antes teníamos que estar mirando qué índice tenía en la lista, en cambio, ahora lo tenemos mucho más sencillo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(mis_amigos['Paloma'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si queremos saber los nombres de cada uno de nuestros amigos podemos listar las claves:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list(mis_amigos.keys())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Y también podemos ver si hemos incluido a un amigo o no en nuestro diccionario:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'Marta' in mis_amigos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La función `dict` nos permite hacer diccionarios directamente desde Tuplas de la siguiente forma:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dict([('Paloma',25), ('Paula',20), ('Teresa',19), ('Marina', 19), \n",
    "      ('Braulio', 21)])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Y cuando las keys son simples string también es posible definir un diccionario de la siguiente forma:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dict(Paloma=25, Paula=20, Teresa=19, Marina=19, Braulio=21)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Iterando sobre diccionarios\n",
    "\n",
    "Es posible crear diccionarios en una sola línea, usando las __dict comprehesions__. En el siguiente ejemplo, cada clave almacena su valor al cuadrado:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "{x: x**2 for x in (2,4,6)}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Aunque también es posible iterar sobre diccionarios usando bucles `for`. Para ello, usamos la función `items`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for nombre, edad in mis_amigos.items():\n",
    "    print(nombre, edad)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cuando iteramos sobre una lista o un conjunto, podemos usar la función `enumerate` para obtener la posición y el elemento de la misma forma:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for posicion, elemento in enumerate(['tic', 'tac', 'toe']):\n",
    "    print(posicion, elemento)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Por último, si queremos iterar sobre dos listas o conjuntos a la vez (del mismo tamaño), podemos hacerlo usando la función `zip`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "questions = ['name', 'quest', 'favourite color']\n",
    "answers = ['lancelot', 'the holy grail', 'blue']\n",
    "\n",
    "for q, a in zip(questions, answers):\n",
    "    print(\"What is your {}? It is {}.\".format(q,a))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En este ejemplo también vemos el uso de la función `format`, que sirve para   meter valores en un string. No sólo se puede usar para imprimir por pantalla sino para guardar valores en una variable y mucho más!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ejercicio\n",
    "\n",
    "__Usando la tupla que creaste en el ejercicio sobre tuplas, crea un diccionario de tu lista de la compra. Una vez tengas el diccionario creado:__\n",
    "\n",
    "* __Imprime todos los elementos que vayas a comprar creando la siguiente frase con la función `format`:__ \"he comprado \\_\\_ y me ha costado \\_\\_\".\n",
    "* __Consulta si has añadido un determinado elemento (por ejemplo un cartón de leche) a la lista de la compra__\n",
    "* __Elimina un elemento usando la función `del`__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}