01-introduccion.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introducción a Python\n",
    "\n",
    "## ¿Qué es Python?\n",
    "\n",
    "* Creado en 1991 por Guido Van Rossum.\n",
    "* Lenguaje de programación de propósito general, multiparadigma (programación imperativa, orientada a objectos, funcional).\n",
    "* Lenguaje de programación interpretado, con tipado dinámico y fuertemente tipado.\n",
    "* [_Batteries Included_](https://docs.python.org/3/tutorial/stdlib.html#batteries-included): Gran cantidad de módulos disponibles en la librería estándar.\n",
    "* Hace énfasis en facilitar la legibilidad y transparencia del código.\n",
    "\n",
    "```python\n",
    ">>> import this\n",
    "The Zen of Python, by Tim Peters\n",
    "\n",
    "Beautiful is better than ugly.\n",
    "Explicit is better than implicit.\n",
    "Simple is better than complex.\n",
    "Complex is better than complicated.\n",
    "Flat is better than nested.\n",
    "Sparse is better than dense.\n",
    "Readability counts.\n",
    "Special cases aren't special enough to break the rules.\n",
    "Although practicality beats purity.\n",
    "Errors should never pass silently.\n",
    "Unless explicitly silenced.\n",
    "In the face of ambiguity, refuse the temptation to guess.\n",
    "There should be one-- and preferably only one --obvious way to do it.\n",
    "Although that way may not be obvious at first unless you're Dutch.\n",
    "Now is better than never.\n",
    "Although never is often better than *right* now.\n",
    "If the implementation is hard to explain, it's a bad idea.\n",
    "If the implementation is easy to explain, it may be a good idea.\n",
    "Namespaces are one honking great idea -- let's do more of those!\n",
    "```\n",
    "\n",
    "## Versiones de Python\n",
    "\n",
    "Hay dos versiones estables de Python, incompatibles entre si: Python 2 (Python 2.7 es la actual versión) y Python 3. La mayor diferencia para un principiante es que en Python 3 `print` pasa a ser una functión y no una sentencia.\n",
    "\n",
    "* Python 2\n",
    "```python\n",
    ">>> print \"Hello World!\"\n",
    "Hello World!\n",
    "```\n",
    "\n",
    "* Python 3\n",
    "```python\n",
    ">>> print \"Hello World!\"\n",
    "  File \"<stdin>\", line 1\n",
    "    print \"Hello World!\"\n",
    "                       ^\n",
    "SyntaxError: Missing parentheses in call to 'print'. Did you mean print(\"Hello World!\")?\n",
    ">>> print(\"Hello World!\")\n",
    "Hello World!\n",
    "```\n",
    "\n",
    "## El intérprete de Python\n",
    "\n",
    "Cuando se ejecuta en modo interactivo, el interprete evalua las entradas que se le introducen a través de un prompt (`>>>`):\n",
    "\n",
    "```python\n",
    "$ python3\n",
    "Python 3.6.6 (default, Jun 27 2018, 14:44:17) \n",
    "[GCC 8.1.0] on linux\n",
    "Type \"help\", \"copyright\", \"credits\" or \"license\" for more information.\n",
    ">>> 1 + 2\n",
    "3\n",
    ">>> a = 1\n",
    ">>> a + 2\n",
    "3\n",
    ">>> b = a + 2\n",
    ">>> b\n",
    "3\n",
    ">>> \n",
    "```\n",
    "\n",
    "Para ejecutar un programa desde la consola:\n",
    "\n",
    "```bash\n",
    "$ python3 hello_world.py\n",
    "Hello world!\n",
    "```\n",
    "\n",
    "En el caso de los _Notebooks_ de Jupyter, el código se agrupa en celdas, que se pueden ejecutar independientemente (ojo a la ejecución fuera de orden). Al ejecutar una celda esta nos devolvera el resultado de la evaluación de la última sentencia ejecutada.\n",
    "\n",
    "## Errores y Excepciones \n",
    "\n",
    "Aunque las veremos más adelante, el interprete genera y lanza excepciones cuando se encuentra algún error. Por ahora, hay que distinguir al menos entre dos tipos de errores, `SyntaxError` y Excepciones.\n",
    "\n",
    "```python\n",
    "$ python3\n",
    "Python 3.6.6 (default, Jun 27 2018, 14:44:17) \n",
    "[GCC 8.1.0] on linux\n",
    "Type \"help\", \"copyright\", \"credits\" or \"license\" for more information.\n",
    ">>>  print(\"Hello World\")\n",
    "  File \"<stdin>\", line 1\n",
    "    print(\"Hello World\")\n",
    "    ^\n",
    "IndentationError: unexpected indent\n",
    ">>> print(Hello World)\n",
    "  File \"<stdin>\", line 1\n",
    "    print(Hello World)\n",
    "                    ^\n",
    "SyntaxError: invalid syntax\n",
    ">>> print(\"Hello World)\n",
    "  File \"<stdin>\", line 1\n",
    "    print(\"Hello World)\n",
    "                      ^\n",
    "SyntaxError: EOL while scanning string literal\n",
    "```\n",
    "\n",
    "## Algunos recursos\n",
    "\n",
    "* Documentación de Python\n",
    "  * [Python 2](https://docs.python.org/3/)\n",
    "    * [Python Tutorial](https://docs.python.org/2/tutorial/index.html)\n",
    "    * **[Python Library](https://docs.python.org/2/library/index.html)**: _keep this under your pillow_\n",
    "    * [Python Language Reference](https://docs.python.org/2/reference/index.html)\n",
    "  * [Python 3](https://docs.python.org/3/)\n",
    "    * [Python Tutorial](https://docs.python.org/3/tutorial/index.html)\n",
    "    * **[Python Library](https://docs.python.org/3/library/index.html)**: _keep this under your pillow_\n",
    "    * [Python Language Reference](https://docs.python.org/3/reference/index.html)\n",
    "* Python Enhancement Proposals.\n",
    "  * [PEP 8 -- Style Guide for Python Code](https://www.python.org/dev/peps/pep-0008/)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "# Un primer programa en Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Hello World!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "# Sintaxis\n",
    "\n",
    "* Sintaxis sencilla, parecida al inglés.\n",
    "* Énfasis en facilitar la lectura del código.\n",
    "* Todas las líneas terminan on un salto de línea (no hace falta `;`).\n",
    "  * Para continuar una línea se utiliza `\\`.\n",
    "* Los comentarios comienzan por un `#`.\n",
    "\n",
    "\n",
    "* Un programa en Python se compone de _módulos_.\n",
    "* Los módulos están compuestos por _sentencias_.\n",
    "  * Las sentencias, en algunos casos, se deben agrupar por bloques.\n",
    "* Las sentencias contienen _expresiones_.\n",
    "  * Crean objetos.\n",
    "  * Procesan objetos.\n",
    "* Los espacios en blanco en Python son muy importantes.\n",
    "  * El indentado delimita bloques de código (funciones, bucles, condicionales, contextos, etc.)\n",
    "  * Normalmente se utilizan 4 espacios en lugar de tabuladores.\n",
    "  * Importante no mezclar espacios y tabuladores!!\n",
    "  * Código en C\n",
    "```c\n",
    "void foo(int x) {\n",
    "        if (x == 0) {\n",
    "            bar();\n",
    "            baz();\n",
    "        } else {\n",
    "            qux(x);\n",
    "            foo(x - 1);\n",
    "        }\n",
    "}\n",
    "```\n",
    "  * Equivalente en Python\n",
    "```python\n",
    "    def foo(x):\n",
    "        if x == 0:\n",
    "            bar()\n",
    "            baz()\n",
    "        else:\n",
    "            qux(x)\n",
    "            foo(x - 1)\n",
    "```\n",
    "  * Código erróneo en Python\n",
    "```python\n",
    "    def foo(x):\n",
    "        if x == 0:\n",
    "            bar()\n",
    "            baz()\n",
    "        else:\n",
    "            qux(x)\n",
    "        foo(x - 1)\n",
    "```\n",
    "  * Código erróneo en Python (fallo de sintaxis)\n",
    "  ```python\n",
    "    def foo(x):\n",
    "        if x == 0:\n",
    "            bar()\n",
    "            baz()\n",
    "        else:\n",
    "            qux(x)\n",
    "           foo(x - 1)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ejemplo (ejecutar la siguiente celda con Ctrl + Enter)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 1\n",
    "b = 10 * 2\n",
    "mensaje = \"Hola a todos\"\n",
    "\n",
    "# Esto es un comentario\n",
    "\n",
    "if b >= 10 or a == 1:\n",
    "    c = a + b\n",
    "    print(mensaje)\n",
    "else:\n",
    "    c = b - a\n",
    "\n",
    "print(\"El resultado es\", c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "\n",
    "# Variables y tipos de datos básicos\n",
    "\n",
    "## Variables\n",
    "\n",
    "* Todo en Python es un objeto (numeros, funciones, cadenas de caracteres, clases, ojetos, modulos, paquetes, etc.).\n",
    "* Las variables se asignan con el operador `=`, sean del tipo que sean.\n",
    "* Se puede asignar cualquier objeto a una variable.\n",
    "* Tipado dinámico, fuertemente tipado."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "a = \"1\"\n",
    "a = 1  # Tipado dinámico\n",
    "\n",
    "b = \"2\"\n",
    "a + b  # Fuertemente tipado"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Una variable tiene que existir para poder referenciarla."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "z  # 'z' no está definida, obtendremos un error"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Los nombres de variables comienzan por un caracter alfabético siempre."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "5cosas = \"hola\"  # Las variables no pueden comenzar por un número"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Números\n",
    "\n",
    "* Dos tipos numéricos básicos.\n",
    "  * enteros, con tipo `int`.\n",
    "  * flotante, con tipo `float`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 1 + 2\n",
    "b = 3\n",
    "c = 12\n",
    "d = a + b**2 + (c / a)\n",
    "c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "13 / 3  # La división siempre devuelve un flotante"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "13 // 3  # Floor division (redondea al entero más próximo)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "13 % 3  # Resto"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Cadenas de caracteres\n",
    "\n",
    "* Python puede manipular cadenas de caracteres, las cadenas se pueden definir:\n",
    "  * Entre comillas dobles (`\"...\")`.\n",
    "  * Entre comillas simples (`'...'`).\n",
    "  * Entre tres comillas dobles (`\"\"\"...\"\"\"`) o tres comillas simples (`'''...'''`) para ocupar varias líneas.\n",
    "  * Para escapar un tipo de comilla dentro de comillas del mismo tipo se utiliza `\\`.\n",
    "  * Dos cadenas adyacentes, separadas por un espacio, son automáticamente añadidas.\n",
    "  * Las cadenas de caracteres se pueden sumar (concatenación)\n",
    "  * Se puede comprobar si una cadena está contenida en otra cadena con el operador \"in\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cadena1 = \"Primera cadena o \\\"string\\\" en inglés.\"\n",
    "\n",
    "cadena2 = 'Segunda cadena o \"string\" en inglés.'\n",
    "\n",
    "cadena3 = \"\"\"Tercera cadena o \"string\", como se\n",
    "ve esta cadena ocupa varias líneas.\n",
    "\n",
    "Aquí termino\"\"\"\n",
    "\n",
    "print(cadena1)\n",
    "print(cadena2)\n",
    "print(cadena3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Esto son\" \"varias cadenas separadas que se van\" \"a juntar al final\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"puede parecer no demasiado útil \"\n",
    "      \"pero es util para romper una cadena\"\n",
    "      \"en varias líneas. \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cadena5 = cadena1 + \" \" + cadena2\n",
    "print(cadena5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"Tercera\" in cadena3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"Cuarta\" in cadena3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ejercicio\n",
    "\n",
    "Imprimir por pantalla el siguiente texto:\n",
    "\n",
    "    He said, \"I'm not going to pass this course\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Escribe aquí tu código\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Listas\n",
    "\n",
    "* Una lista es una secuencia de objetos, separados por comas, entre corchetes.\n",
    "* Una lista está ordenada mediante un índice numérico, que comienza en 0.\n",
    "* Puede contener cualquier objeto en Python, se pueden mezclar objetos de diferente tipo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lista_vacia = []\n",
    "lista_vacia"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lista1 = [\"a\", \"b\", \"c\", \"d\", \"e\", \"f\"]\n",
    "lista2 = [2, lista1, 13.5]\n",
    "lista3 = [3, lista2]\n",
    "print(lista1)\n",
    "print(lista2)\n",
    "print(lista3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* A los elementos de una lista se accede mediante su índice.\n",
    "  * El índice comienza en 0\n",
    "  * El último índice es -1\n",
    "* Una lista (y cualquier otra secuencia) se puede _rebanar_ (slice) para obtener una sublista, utilizando `[M:N]` (`M` y `N` son los índices a utilizar.\n",
    "  * Devuelve una sublista desde la posición `M` (incluida) hasta `N` (no incluida).\n",
    "  * Si se omite `M`, el índice es `0`\n",
    "  * Si se omite `N`, el índice es el tamaño de la lista."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lista1[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lista1[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lista1[2:4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lista1[:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lista1[:5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lista1[0] = \"z\"\n",
    "lista1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Al igual que con las cadenas de caracteres, se puede comprobar si un elemento está en una lista con el operador `in`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"a\" in lista1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"b\" in lista1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Añadiendo, reemplazando y eliminando elementos\n",
    "\n",
    "* A una lista se pueden añadir elementos de varias maneras.\n",
    "  * Mediante el método `append`.\n",
    "  * Mediante el método `insert`.\n",
    "  * Mediante el método `extend`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lista = [\"Hola\", \"todos,\", \"que\", \"tal\"]\n",
    "lista.append(\"estáis?\")\n",
    "print(\"Después de append:\", lista)\n",
    "\n",
    "lista.insert(1, \"a\")\n",
    "print(\"Después de insert:\", lista)\n",
    "\n",
    "lista.extend([\"Espero\", \"que\", \"bien\"])\n",
    "print(\"Después de extend:\", lista)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Se pueden cambiar elementos de una lista, a través del índice que se quiera cambiar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lista[3] = \"¿que\"\n",
    "print(lista)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Del mismo modo, se puede eliminar elementos de varias maneras.\n",
    "  * Mediante el método `remove`.\n",
    "  * Mediante el método `pop`.\n",
    "  * Mediante la function `del`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lista.remove(\"Hola\")\n",
    "print('Elimino \"Hola\":', lista)\n",
    "\n",
    "lista.pop()\n",
    "print('Elimino el último elemento:', lista)\n",
    "\n",
    "del lista[3]\n",
    "print(\"Elimino el elemento del índice 3:\", lista)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Operaciones sobre listas\n",
    "* Una lista se puede sumar y multiplicar."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lista1 = [1, 2, 3]\n",
    "lista2 = [\"a\", \"b\", \"c\"]\n",
    "lista1 + lista2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lista2 * 2 + lista1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tuplas\n",
    "\n",
    "* Una tupla es una secuencia de objetos, separados por comas, entre paréntesis.\n",
    "* Las tuplas, como las listas, están ordenadas.\n",
    "* Una tupla es una secuencia inmutable, una vez creada no se puede modificar.\n",
    "  * El resto de operaciones sobre secuencias si se pueden aplicar.\n",
    "  * Una tupla NO tiene métodos (`append`, `extend`, etc.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t = (1, 2, 3)\n",
    "t[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t[0] = \"uno\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t + t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t * 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Una tupla vacía se define de la siguiente forma"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t = ()\n",
    "t"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Pero una tupla de un elemento se define de la siguiente forma."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t = (1)  # Esto NO es una tupla\n",
    "t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t = (1, )  # Una coma siempre al final\n",
    "t"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Secuencias\n",
    "\n",
    "* Las listas, tuplas y *cadenas de caracteres* son secuencias.\n",
    "* Muchas propiedades en común.\n",
    "  * Indexado, slicing, etc.\n",
    "* Operaciones en secuencias\n",
    "\n",
    "| Operation | Result |\n",
    "|-----------------------|-----------------------------------------------|\n",
    "|`x in s`               |True if an item of s is equal to x, else False |\n",
    "|`x not in s`           |False if an item of s is equal to x, else True |\n",
    "|`s + t`                |the concatenation of s and t |\n",
    "|`s * n or n * s`       |equivalent to adding s to itself n times \t|\n",
    "|`s[i]`                 |ith item of s, origin 0 \t|\n",
    "|`s[i:j]`               |slice of s from i to j \t|\n",
    "|`s[i:j:k]`             |slice of s from i to j with step k \t|\n",
    "|`len(s)`               |length of s \t |\n",
    "|`min(s)`               |smallest item of s \t |\n",
    "|`max(s)`               |largest item of s \t |\n",
    "|`s.index(x[, i[, j]])` |index of the first occurrence of x in s (at or after index i and before index j) |\n",
    "|`s.count(x)`           |total number of occurrences of x in s \t |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cadena = \"Hola a todos que tal estáis\"\n",
    "cadena[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cadena[7:12]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(cadena)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Diccionarios\n",
    "\n",
    "* Conjunto de pares `clave:valor`, definidos entre llaves.\n",
    "  * `{}` Define un diccionario vacío.\n",
    "  * La función `dict()` pued recibir una secuencia de pares `clave, valor` para constuir un diccionario\n",
    "  * La función `dict()` también puede recibir argumentos para crear el diccionario.\n",
    "* Las claves son únicas en un diccionario.\n",
    "* Se puede acceder a (y modificar) los elementos a través de su `clave`.\n",
    "* Pero no se puede acceder a las `claves` a través de su valor.\n",
    "* Un diccionario puede tener como elemento cualquier objeto en Python (incluidos otros diccionarios)\n",
    "* Se puede comprobar si una llave está en un diccionario con el operador `in`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "diccionario_vacio = {}\n",
    "diccionario_vacio "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dict1 = {\n",
    "    \"nombre\": \"Álvaro\",\n",
    "    \"apellido\": \"López\",\n",
    "    \"master\": \"data science\",\n",
    "}\n",
    "dict1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dict1 = dict([(\"nombre\", \"Álvaro\"), (\"apellido\", \"López\"), (\"master\", \"data science\")])\n",
    "dict1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dict1 = dict(nombre=\"Álvaro\", apellido=\"López\", master=\"data science\")\n",
    "dict1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dict1= {}\n",
    "dict1[\"nombre\"] = \"Alvaro\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dict1[\"apellido\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d = {\"nombre\": \"Sebastian\", \"cuenta\": 10}\n",
    "d[\"cuenta\"] += 1\n",
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"nombre\" in d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"apellido\" in d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Más complicado\n",
    "\n",
    "d = {\n",
    "    \"datos\": {\n",
    "        \"nombre\": \"alvaro\",\n",
    "        \"apellido\": \"lopez\",\n",
    "    },\n",
    "    \"master\": \"data science\",\n",
    "}\n",
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d[\"datos\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Nombre:\", d[\"datos\"][\"nombre\"], \"-- apellido:\", d[\"datos\"][\"apellido\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Más complicado\n",
    "\n",
    "d = {\n",
    "    \"alumnos\": [\n",
    "        {\"nombre\": \"federico\"},\n",
    "        {\"nombre\": \"sebastian\"},\n",
    "    ],\n",
    "    \"master\": \"data science\",\n",
    "    \"curso\": \"2017, 2018\",\n",
    "}\n",
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Otros métodos interesantes son:\n",
    "  * `.keys()` Devuelve todas las llaves del diccionario.\n",
    "  * `.values()` Devuelve todos los valores del diccionario.\n",
    "  * `.pop(item)` Extrae el elemento con llave `item` del diccionario."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conjuntos\n",
    "\n",
    "* Conjunto de valores sin orden y sin duplicados.\n",
    "* Se definen entre llaves, separando los elementos por comas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = {1, 2, 3, 4, 5}\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "1 in a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tipo booleano\n",
    "\n",
    "* En Python, casi cualquier cosa es verdadero, excepto:\n",
    "  * `[]` -> Lista vacía\n",
    "  * `{}` -> Diccionario vacío\n",
    "  * `\"\"` -> Cadena vacía\n",
    "  * `0`, `0.0`\n",
    "  * `False` \n",
    "  * `None`\n",
    "* Operadores: `not`, `and` y `or`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "True and False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "False or True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "True and not False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "False and False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ejercicio\n",
    "\n",
    "* Dada la siguiente lista, eliminar las cadenas de caracteres presentes en ella y ordenarla."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lista = [9, 7, 14, 12, 10, 9, \"Hola\", 0, 23, 12, \"Alvaro\", 12]\n",
    "\n",
    "# Escribe aquí tu código\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Dado el siguiente diccionario\n",
    "  * Añadir el elemento \"master\" con el valor \"data science\".\n",
    "  * Añadir a la lista de alumnos el nombre \"sebastian\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dict1 = {\n",
    "    \"alumnos\": [\"juan\", \"pedro\", \"francisco\"],\n",
    "    \"curso\": \"2017, 2018\",\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Dados los siguientes dos diccionarios, actualizar con los datos del segundo diccionario el primero."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "valores_por_defecto = {\n",
    "    \"nombre\": None,\n",
    "    \"altura\": 1000,\n",
    "    \"anchura\": 1000,\n",
    "    \"localización\": \"Santander\",\n",
    "    \"coordenadas\": (43.4722475, -3.8199358),\n",
    "}\n",
    "\n",
    "valores_actualizar = {\n",
    "    \"altura\": 100,\n",
    "    \"anchura\": 200,\n",
    "    \"nombre\": \"columna\"\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "# Estructuras de control\n",
    "\n",
    "* El código en un programa (o módulo) de Python se evalua de formas secuencial\n",
    "  * Comenzando por la primera línea\n",
    "  * Hasta el final o hasta que la ejecución se interrumpe\n",
    "* Pero hay mecanismos para modificar este flujo: Condicionales y bucles.\n",
    "\n",
    "\n",
    "## Sentencia condicional: if\n",
    "\n",
    "* Los condicionales permiten ejecutar un bloque de código u otro, dependiendo de una condición.\n",
    "* La sentencia condicional es de la siguiente forma:\n",
    "```python\n",
    "if test1:\n",
    "    statement_1\n",
    "else:\n",
    "    statement_2\n",
    "```\n",
    "* Si `test1` es verdadero, se ejecturará `statement_1`. Si es falso, se ejecutará `statement_2`.\n",
    "* Se pueden añadir mas concionales:\n",
    "```python\n",
    "if test1:\n",
    "    statement_1\n",
    "elif test2:\n",
    "    statement_2\n",
    "elif test3:\n",
    "    statement_3\n",
    "else:\n",
    "    statement_4\n",
    "```\n",
    "* Tanto los `elif` como los `else` son opcionales.\n",
    "* El bloque de código a ejecutar viene determinado por el sangrado del mismo\n",
    "* En Python no existen sentencias `case` o `switch`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Condicionales y condiciones\n",
    "\n",
    "* Recordemos, en Python, casi cualquier cosa es verdadero, excepto:\n",
    "  * `[]` -> Lista vacía\n",
    "  * `{}` -> Diccionario vacío\n",
    "  * `\"\"` -> Cadena vacía\n",
    "  * `0`, `0.0`\n",
    "  * `False` \n",
    "  * `None`\n",
    "* Operadores booleanos: `not`, `and` y `or`.\n",
    "* Python usa _short-cirtuit_ operation: En una operación booleana, Python evalua de izquierda a derecha y devuelve el primero que es verdadero, parando en ese momento.\n",
    "\n",
    "| Operador | Significado |\n",
    "| --- | ---| \n",
    "| `>`  |\tstrictly less than | \n",
    "| `<=` | \tless than or equal |\n",
    "| `>`  | \tstrictly greater than |\n",
    "| `>=` |\tgreater than or equal |\n",
    "| `==` | \tequal |\n",
    "| `!=` | \tnot equal |\n",
    "| `is` | \tobject identity |\n",
    "| `is not` | \tnegated object identity |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "True and 2 and 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "0 or 3 or 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "0 and 1 and 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l = [1, 2, 3, 4]\n",
    "\n",
    "value = 2\n",
    "\n",
    "if value in l:\n",
    "    print(\"El valor\", value, \"está en la lista\")\n",
    "else:\n",
    "    print(\"El valor\", value, \"no está en la lista\")\n",
    "    \n",
    "if value > 0: \n",
    "    print(\"Valor positivo\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Bucles\n",
    "\n",
    "* Los bucles (`for` y `while`) se utilizan para ejecutar un bloque de código un número determinado de veces.\n",
    "* Se puede salir de un bucle mediante la sentencia `break`.\n",
    "* Se puede continuar a la siguiente iteración con `continue`\n",
    "\n",
    "### Bucles: for\n",
    "\n",
    "* Un bucle for se utiliza para iterar sobre un _iterable_ (secuencia).\n",
    "* Diferencia con otros lenguajes donde se itera siempre sobre una secuencia de números.\n",
    "* Se ejecuta el bloque de código correspondiente para todos los elementos del iterable.\n",
    "* Puede tener una setencia `else`, que se ejecuta cuando el bucle termina su secuencia.\n",
    "* Sintaxis:\n",
    "```python\n",
    "for item in sequence:\n",
    "    statement_1\n",
    "else:\n",
    "    statement_2\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for word in [\"Hola\", \"que\", \"tal\", \"estais?\"]:\n",
    "    print(word)\n",
    "else:\n",
    "    print(\"Terminé el bucle\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lista = [\"Hola\", \"que\", \"tal\", \"estais?\"]\n",
    "lista_mayus = []\n",
    "\n",
    "for word in lista:\n",
    "    word = word.upper()\n",
    "    lista_mayus.append(word)\n",
    "    print(word)\n",
    "    \n",
    "print(lista_mayus)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lista = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
    "for num in lista:\n",
    "    print(num)\n",
    "    if num == 5:\n",
    "        break\n",
    "else:\n",
    "    print(\"No hay más números\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Iterar sobre una secuencia *no* crea una copia de la secuencia.\n",
    "  * No es conveniente modificar la secuencia mientras se itera, podemos terminar en un bucle infinito.\n",
    "  * Es necesario crear una copia de la misma."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# NO: Este código no termina nunca\n",
    "\n",
    "# lista = [\"Hola\", \"que\", \"tal\", \"estais?\"]\n",
    "#\n",
    "#for word in lista:\n",
    "#    if word == \"Hola\":\n",
    "#        lista.insert(0, word)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# SI: Este código si termina\n",
    "\n",
    "lista = [\"Hola\", \"que\", \"tal\", \"estais?\"]\n",
    "\n",
    "for word in lista[:]:\n",
    "    if word == \"Hola\":\n",
    "        lista.insert(0, word)\n",
    "print(lista)\n",
    "\n",
    "# Este tambien\n",
    "lista = [\"Hola\", \"que\", \"tal\", \"estais?\"]\n",
    "\n",
    "for word in list(lista):\n",
    "    if word == \"Hola\":\n",
    "        lista.insert(0, word)\n",
    "print(lista)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Hay [funciones interesantes en la librería estándar](https://docs.python.org/3.7/library/functions.html) para los bucles:\n",
    "  * `enumerate`\n",
    "  * `len`\n",
    "  * `max`, `min`\n",
    "  * `range`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lista = [\"Hola\", \"que\", \"tal\", \"estais?\"]\n",
    "\n",
    "for idx, word in enumerate(lista[:]):\n",
    "    if idx == 1:\n",
    "        lista.insert(1, \"a\")\n",
    "    if idx == 2:\n",
    "        lista.insert(2, \"todos\")\n",
    "    print(idx, word)\n",
    "print(lista)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Ejercicio\n",
    "\n",
    "* Calcular la suma de los 1000 primeros números enteros, utilizando un bucle for."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Escribe aquí tu código\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Bucles: while\n",
    "\n",
    "* Un bucle while se ejecuta mientras una condición determinada se cumpla siempre.\n",
    "* Puede tener una setencia `else`, que se ejecuta cuando la condición cambia a falso.\n",
    "* Su sintaxis es:\n",
    "```python\n",
    "while condicion:\n",
    "    statement\n",
    "else:\n",
    "    statement\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Ejercicio\n",
    "\n",
    "* Calcular la serie de Fibonacci utilizando un bucle while para los 20 primeros elementos\n",
    "* La serie de Fibonacci para el elemento N se obtiene mendiante la suma de N-1 y N-2."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Escribe aquí tu código\n",
    "\n",
    "\n",
    "\n"
   ]
  }
 ],
 "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}