01-Introduccion-a-la-Programacion-en-Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introducci&oacute;n a la programaci&oacute;n en Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Versi&oacute;n original en ingl&eacute;s de [J.R. Johansson](http://jrjohansson.github.io/) (robert@riken.jp).\n",
    "\n",
    "Traducido/Adaptado por [G.F. Rubilar](http://google.com/+GuillermoRubilar).\n",
    "\n",
    "La &uacute;ltima versi&oacute;n de estos [Notebooks](http://ipython.org/notebook.html) est&aacute; disponible en [http://github.com/gfrubi/clases-python-cientifico](http://github.com/gfrubi/clases-python-cientifico).\n",
    "\n",
    "La &uacute;ltima versi&oacute;n del original (en ingl&eacute;s) est&aacute; disponible en [http://github.com/jrjohansson/scientific-python-lectures](http://github.com/jrjohansson/scientific-python-lectures).\n",
    "Los otros notebooks de esta serie est&aacute;n listados en [http://jrjohansson.github.com](http://jrjohansson.github.com)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Archivos de programa en Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* El c&oacute;digo Python es usualmente almacenado en archivos de texto con extensi&oacute;n \"`.py`\" (un \"script\"):\n",
    "\n",
    "        miprograma.py\n",
    "\n",
    "* Se asume que cada l&iacute;nea de un archivo de programa en Python es una sentencia Python, o parte de una sentencia. \n",
    "\n",
    "    * La &uacute;nica excepci&oacute;n son las l&iacute;neas de comentarios, que comienzan con el caracter `#` (opcionalmente precedida por un n&uacute;mero arbitrario de caracteres de espacio en blanco, es decir, tabs y espacios. Las l&iacute;neas de comentarios son usualmente ignoradas por el int&eacute;rprete Python.\n",
    "\n",
    "\n",
    "* Para ejecutar nuestro programa Python desde la l&iacute;nea de comando usamos:\n",
    "\n",
    "        $ python miprograma.py\n",
    "\n",
    "* En sistemas UNIX es com&uacute;n definir la ruta al int&eacute;rprete en la primera l&iacute;nea del programa (note que &eacute;sta es una l&iacute;nea de comentarios en lo que respecta al int&eacute;rprete Python):\n",
    "\n",
    "        #!/usr/bin/env python\n",
    "\n",
    "  Si hacemos esto, y adicionalmente configuramos el archivo para que sea ejecutable, podemos correr el programa usando:\n",
    "\n",
    "        $ miprograma.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Codificaci&oacute;n de caracteres"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La codificaci&oacute;n est&aacute;ndar de caracteres es la ASCII, pero podemos usar cualquier otra codificaci&oacute;n, por ejemplo UTF-8. Para especificar que usamos UTF-8 incluimos la l&iacute;nea especial\n",
    "\n",
    "    # -*- coding: UTF-8 -*-\n",
    "\n",
    "al comienzo del archivo."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Aparte de estas dos l&iacute;neas *opcionales* al comienzo de un archivo Python, no se requiere de otro c&oacute;digo adicional para inicializar un programa. Por otro lado, en la versi&oacute;n 3 de Python ya no es necesario agregar c&oacute;digo extra alguno."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Jupyter Notebooks"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Este archivo - un Jupyter/IPython notebook -  no sigue el patr&oacute;n est&aacute;ndar de c&oacute;digo Python en un archivo de texto. En su lugar, un notebook IPython es almacenado como un archivo en el formato [JSON](http://es.wikipedia.org/wiki/JSON). La ventaja es que podemos mezclar texto formateado, c&oacute;digo Python, y c&oacute;digo de salida. Esto requiere estar ejecutando un servidor de notebook IPython, y por eso este tipo de archivo no es un programa Python independiente como se describi&oacute; antes. Aparte de eso, no hay diferencia entre el c&oacute;digo Python en un archivo de programa o en un notebook IPython."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variables y tipos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Nombres de s&iacute;mbolos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " Los nombres de las variables en Python pueden contener los caracteres `a-z`, `A-Z`, `0-9` y algunos caracteres especiales como `_`. Los nombres de variables normales deben comenzar con una letra. \n",
    "\n",
    "Por convenci&oacute;n, los nombres de las variables comienzan con letra min&uacute;scula, mientras que los nombres de las clases comienzan con una letra may&uacute;scula. \n",
    "\n",
    "Adem&aacute;s, existen algunos palabras claves Python que no pueden ser usados como nombres de variables. &Eacute;stas son:\n",
    "\n",
    "    and, as, assert, break, class, continue, def, del, elif, else, except, \n",
    "    exec, finally, for, from, global, if, import, in, is, lambda, not, or,\n",
    "    pass, print, raise, return, try, while, with, yield\n",
    "\n",
    "Nota: Atenci&oacute;n con la palabra `lambda`, que podr&iacute;a f&aacute;cilmente ser un nombre de variable natural en un programa cient&iacute;fico. Sin embargo, como es una palabra clave, no puede ser usado como nombre de una variable."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Asignaciones"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El operador para asignar valores en Python es el signo igual (`=`). Python es un lenguage de _escritura din&aacute;mica_, de modo que no necesitamos especificar el tipo de una variable cuando la creamos.\n",
    "\n",
    "Al asignar un valor a una variable nueva se crea esa variable:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# asignaciones de variables\n",
    "x = 1.0\n",
    "mi_variable = 12.2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Aunque no se especifique expl&iacute;citamente, cada variable s&iacute; tiene un tipo asociada a ella. El tipo es extraido del valor que le fue asignado."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si asignamos un nuevo valor a una variable, su tipo puede cambiar."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si tratamos de usar una variable que no ha sido definida obtenemo un mensaje de error (`NameError`):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tipos Fundamentales"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# enteros\n",
    "x = 1\n",
    "type(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# flotantes\n",
    "x = 1.0\n",
    "type(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# booleanos\n",
    "b1 = True\n",
    "b2 = False\n",
    "\n",
    "type(b1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# n&uacute;meros complejos: note que se usa `j` para especificar la parte imaginaria\n",
    "x = 1.0 - 1.0j\n",
    "type(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "print(x.real, x.imag)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 1.0\n",
    "\n",
    "# verifica si la variable x es flotante\n",
    "type(x) is float"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# verifica si la variable x es un entero\n",
    "type(x) is int"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos tambi&eacute;n usar el m&eacute;todo `isinstance` para testear tipos de variables:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "isinstance(x, float)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Conversi&oacute;n de Tipo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 1.5\n",
    "\n",
    "print(x, type(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = int(x)\n",
    "\n",
    "print(x, type(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "z = complex(x)\n",
    "\n",
    "print(z, type(z))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = float(z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Un n&uacute;mero complejo no puede ser convertido a un n&uacute;mero flotante o a un entero. Necesitamos usar `z.real`, o bien `z.imag`, para extraer la parte que deseamos del n&uacute;mero complejo z:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y = bool(z.real)\n",
    "\n",
    "print(z.real, \" -> \", y, type(y))\n",
    "\n",
    "y = bool(z.imag)\n",
    "\n",
    "print(z.imag, \" -> \", y, type(y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Operadores y comparaciones\n",
    "\n",
    "La mayor&iacute;a de los operadores y las comparaciones en Python funcionan como se esperar&iacute;a:\n",
    "\n",
    "* Operadores aritm&eacute;ticos `+`, `-`, `*`, `/`, `//` (divisi&oacute;n entera), '**' potencia\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "1 + 2, 1 - 2, 1 * 2, 1 / 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "1.0 + 2.0, 1.0 - 2.0, 1.0 * 2.0, 1.0 / 2.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Divisi&oacute;n entera de dos n&uacute;menos flotantes\n",
    "3.0 // 2.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Atenci&oacute;n! El operador de potencia en Python no es ^, sino **\n",
    "2**2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Los operadores booleanos se escriben como palabras: `and`, `not`, `or`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "True and False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "not False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "True or False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Operadores de comparaci&oacute;n `>`, `<`, `>=` (mayor o igual), `<=` (menor o igual), `==` igualdad, `es` id&eacute;ntico."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "2 > 1, 2 < 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "2 > 2, 2 < 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "2 >= 2, 2 <= 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# igualdad\n",
    "[1,2] == [1,2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# &iquest;objetos id&eacute;nticos?\n",
    "l1 = l2 = [1,2]\n",
    "\n",
    "l1 is l2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tipos compuestos: Cadenas, listas y diccionarios\n",
    "\n",
    "### Cadenas\n",
    "\n",
    "Las cadenas son el tipo de variables que es usado para almacenar mensajes de texto. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = \"Hola mundo\"\n",
    "type(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# longitud de la cadena: el n&uacute;mero de caracteres que contiene\n",
    "len(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# reemplaza una subcadena de una cadena por cadena\n",
    "s2 = s.replace(\"mundo\", \"universo\")\n",
    "print(s2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos aislar un car&aacute;cter en una cadena usando `[]`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Atenci&oacute;n usuarios de MATLAB:** el indexado comienza en 0!\n",
    "\n",
    "Podemos extraer una parte de una cadena usando la sintaxis `[desde:hasta]`, que extrae caracteres entre los &iacute;ndices  `desde` y `hasta` **sin incluir el elemento con &iacute;ndice `hasta'**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s[0:5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si omitimos `desde` o bien `hasta` de `[desde:hasta]`, por defecto se entiende que se refiere al comienzo y/o al fin de la cadena, respectivamente:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s[:5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s[6:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s[:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos tambi&eacute;n definir el tama&ntilde;o del paso usando la sintaxis `[desde:hasta:paso]` (el valor por defecto de `paso` es 1, como ya vimos):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s[::1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s[::2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Esta t&eacute;cnica es llamada *slicing* (\"rebanado\"). Puede leer m&aacute;s sobre la sintaxis [aqu&iacute;](http://pyspanishdoc.sourceforge.net/lib/built-in-funcs.html) y [aqu&iacute;](http://docs.python.org/release/2.7.3/library/functions.html?highlight=slice#slice) (en ingl&eacute;s)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python tiene un rico conjunto de funciones para procesar texto. Ver por ejemplo la documentaci&oacute;n en [este link](http://docs.python.org/2/library/string.html) (en ingl&eacute;s) para m&aacute;s informaci&oacute;n."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Ejemplos de formateo de cadenas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"uno\", \"dos\", \"tres\")  # El comando print puede desplegar varias cadenas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"uno\", 1.0, False, -1j)  # El comando print convierte todos los argumentos a cadenas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"uno\" + \"dos\" + \"tres\") # cadenas \"sumadas\" con + son contatenadas sin espacio entre ellas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"valor = \"+str(1.0)) # podemos transformar un float a string y concatenarlos en la salida"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"valor = %f\" % 1.0) # podemos usar formateo de cadenas en el estilo del lenguaje C"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# este formateo crea una cadena\n",
    "s2 = \"valor1 = %.2f. valor2 = %d\" % (3.1415, 1.5)\n",
    "\n",
    "print(s2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# forma alternativa, m&aacute;s intuitiva para formatear una cadena\n",
    "s3 = 'valor1 = {0}, valor2 = {1}'.format(3.1415, 1.5)\n",
    "\n",
    "print(s3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Listas\n",
    "\n",
    "Listas son muy similares a las cadenas, excepto que cada elemento puede ser de un tipo diferente.\n",
    "\n",
    "La sintaxis para crear listas en Python es `[..., ..., ...]`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l = [1,2,3,4]\n",
    "\n",
    "print(type(l))\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos usar las mismas t&eacute;cnicas de \"rebanado\" que usamos en el caso de cadenas para manipular listas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(l)\n",
    "\n",
    "print(l[1:3])\n",
    "\n",
    "print(l[::2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Atenci&oacute;n usuarios de MATLAB:** el indexado comienza en 0!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Los elementos en una lista no requieren ser del mismo tipo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l = [1, 'a', 1.0, 1-1j]\n",
    "\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Las listas en Python pueden ser *inhomog&eacute;neas* y *arbitrariamente anidadas*:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lista_anidada = [1, [2, [3, [4, [5]]]]]\n",
    "\n",
    "lista_anidada"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Las listas juegan un rol muy importante en Python y son, por ejemplo, usadas en bucles y otras estructuras de control de flujo (discutidas m&aacute;s abajo). Existen muchas funciones convenientes para generar listas de varios tipos, por ejemplo la funci&oacute;n `range`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "desde = 10\n",
    "hasta = 30\n",
    "paso = 2\n",
    "\n",
    "range(desde, hasta, paso)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# en Python 3 range genera un interador, que puede ser convertido a una lista usando 'list(...)'. Esto no tiene efecto en Python 2\n",
    "list(range(desde, hasta, paso))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list(range(-10, 10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# convierte una cadena a una lista, por conversi&oacute;n de tipo:\n",
    "\n",
    "s2 = list(s)\n",
    "\n",
    "s2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ordenando listas\n",
    "s2.sort()\n",
    "\n",
    "print(s2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Agregando, insertando, modificando, y removiendo elementos de listas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# crea una nueva lista vac&iacute;a\n",
    "l = []\n",
    "\n",
    "# agrega un elemento a la lista, usando `append`\n",
    "l.append(\"A\")\n",
    "l.append(\"d\")\n",
    "l.append(\"d\")\n",
    "\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos modificar listas asignando nuevos valores a los elementos de la lista. En lenguaje t&eacute;cnico se dice que la lista es *mutable*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l[1] = \"p\"\n",
    "l[2] = \"p\"\n",
    "\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l[1:3] = [\"d\", \"d\"]\n",
    "\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Insertar un elemento en una posici&oacute;n espec&iacute;fica `insert`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l.insert(0, \"i\")\n",
    "l.insert(1, \"n\")\n",
    "l.insert(2, \"s\")\n",
    "l.insert(3, \"e\")\n",
    "l.insert(4, \"r\")\n",
    "l.insert(5, \"t\")\n",
    "\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Eliminar el primer elemento con un valor espec&iacute;fico usando 'remove'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l.remove(\"A\")\n",
    "\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Eliminar un elemento en una posici&oacute;n espec&iacute;fica usando `del`:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Puede introducir `help(list)` para m&aacute;s detalles, o leer la documentaci&oacute;n en la red"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tuplas\n",
    "\n",
    "Tuplas son similares a las listas, excepto que ellas no pueden ser modificadas una vez creadas, es decir, son *inmutables*. \n",
    "\n",
    "En Python, las tuplas son creadas usando la sintaxis `(..., ..., ...)`, o incluso `..., ...`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "punto = (10, 20)\n",
    "\n",
    "print(punto, type(punto))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "punto = 10, 20\n",
    "\n",
    "print(punto, type(punto))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos separar una tupla asign&aacute;ndola a una lista de variables separadas por coma:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x, y = punto\n",
    "\n",
    "print(\"x =\", x)\n",
    "print(\"y =\", y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si intentamos asignar un nuevo valor a un elemento de una tupla obtenemos un error:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "punto[0] = 20"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Diccionarios\n",
    "\n",
    "Los diccionarios son tambi&eacute;n como listas, excepto que cada elemento es un par clave-valor. La sintaxis de los diccionarios es `{clave1 : valor1, ...}`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "parametros = {\"clave1\" : 1.0, \"clave2\" : True, \"clave3\" : \"hola\"}\n",
    "\n",
    "print(type(parametros))\n",
    "print(parametros)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "parametros[\"clave1\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"clave1 --> \" + str(parametros[\"clave1\"]))\n",
    "print(\"clave2 --> \" + str(parametros[\"clave2\"]))\n",
    "print(\"clave3 --> \" + str(parametros[\"clave3\"]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "parametros[\"clave1\"] = \"A\"\n",
    "parametros[\"clave2\"] = (4<2)\n",
    "\n",
    "# agrega una nueva entrada\n",
    "parametros[\"clave4\"] = \"D\"\n",
    "\n",
    "print(\"clave1 = \" + str(parametros[\"clave1\"]))\n",
    "print(\"clave2 = \" + str(parametros[\"clave2\"]))\n",
    "print(\"clave3 = \" + str(parametros[\"clave3\"]))\n",
    "print(\"clave4 = \" + str(parametros[\"clave4\"]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Control de flujo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sentencias condicionales: if, elif, else\n",
    "\n",
    "La sintaxis Python para la ejecuci&oacute;n condicional de c&oacute;digo usa las palabras clave `if`, `elif` (else if), `else`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "afirmacion1 = False\n",
    "afirmacion2 = False\n",
    "\n",
    "if afirmacion1:\n",
    "    print(\"afirmacion1 es verdadera\")\n",
    "    \n",
    "elif afirmacion2:\n",
    "    print(\"afirmacion2 es verdadera\")\n",
    "    \n",
    "else:\n",
    "    print(\"afirmacion1 y afirmacion2 son falsas\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Aqu&iacute; encontramos por primera vez un aspecto pecular e inusual del lenguaje Python: Los bloques del programa son definidos por su nivel de indentaci&oacute;n (la cantidad de espacio antes de cada linea). \n",
    "\n",
    "Compare con el c&oacute;digo equivalente en C:\n",
    "\n",
    "    if (afirmacion1)\n",
    "    {\n",
    "        printf(\"afirmacion1 es verdadera\\n\");\n",
    "    }\n",
    "    else if (afirmacion2)\n",
    "    {\n",
    "        printf(\"afirmacion1 es verdadera\\n\");\n",
    "    }\n",
    "    else\n",
    "    {\n",
    "        printf(\"afirmacion1 y afirmacion2 son falsas\\n\");\n",
    "    }\n",
    "\n",
    "En C los bloques son definidos por los par&eacute;ntesis llaves `{` y `}`. El nivel de indentaci&oacute;n (espacio en blanco antes del c&oacute;digo) no importa (es completamente opcional). \n",
    "\n",
    "En Python, la extensi&oacute;n de un bloque de c&oacute;digo es definido por el nivel de indentaci&oacute;n (usualmente un tab o cuatro espacios en blanco). Esto significa que debemos ser cuidados@s de indentar nuestro c&oacute;digo correctamente, de lo contrario tendremos errores de sintaxis. Adem&aacute;s, pueden presentarse errores en la ejecuci&oacute;n si se es inconsistente en la forma que se realiza el indentado en un mismo programa.\n",
    "\n",
    "**Ejemplos:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "afirmacion1 = afirmacion2 = True\n",
    "\n",
    "if afirmacion1:\n",
    "    if afirmacion2:\n",
    "        print(\"tanto afirmacion1 como afirmacion2 son verdaderas\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Mala indentaci&oacute;n!\n",
    "if afirmacion1:\n",
    "    if afirmacion2:\n",
    "    print(\"tanto afirmacion1 como afirmacion2 son verdaderas\")  # esta l&iacute;nea est&aacute; mal indentada"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "afirmacion1 = False \n",
    "\n",
    "if afirmacion1:\n",
    "    print(\"afirmacion1 es verdadera\")\n",
    "    \n",
    "    print(\"aun estamos dentro del bloque if\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if afirmacion1:\n",
    "    print(\"afirmacion1 es verdadera\")\n",
    "    \n",
    "print(\"ahora estamos fuera del bloque\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ciclos\n",
    "\n",
    "En Python, los ciclos (loops) puede ser programados de varias maneras diferentes. La forma m&aacute;s com&uacute;n es usando un ciclo `for`, que se usa junto con objetos iterables, como por ejemplos las listas. La sintaxis b&aacute;sica es:\n",
    "\n",
    "\n",
    "**Ciclos `for`**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for x in [1,2,3]:\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El ciclo `for` itera sobre los elementos de la lista suministrada y ejecuta el bloque suministrado una vez para cada elemento. Cualquier tipo de lista puede ser usada para un ciclo `for`. Por ejemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for x in range(4): # por defecto range comienza con 0\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nota: `range(4)` no incluye el 4 !"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for x in range(-3,3):\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for palabra in [\"computaci&oacute;n\", \"cient&iacute;fica\", \"con\", \"Python\"]:\n",
    "    print(palabra)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para iterar sobre pares clave-valor en un diccionario:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for clave, valor in parametros.items():\n",
    "    print(clave + \" = \" + str(valor))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Algunas veces es &uacute;til tener acceso a los &iacute;ndices de los valores mientras se itera sobre una lista. Podemos usar la funci&oacute;n `enumerate` para esto:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for idx, x in enumerate(range(-3,3)):\n",
    "    print(idx, x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "** Listas: Creando listas usando ciclos `for`**:\n",
    "\n",
    "Una forma conveniente y compacta de inicializar listas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l1 = [x**2 for x in range(0,5)]\n",
    "\n",
    "print(l1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ciclos `while`**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "i = 0\n",
    "\n",
    "while i < 5:\n",
    "    print(i)    \n",
    "    i = i + 1\n",
    "    \n",
    "print(\"listo\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note que el comando`print(\"listo\")` no es parte del cuerpo del ciclo `while`, debido a su indentaci&oacute;n."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Funciones\n",
    "\n",
    "En Python una funci&oacute;n es definida usando la palabra clave `def`, seguida de un nombre para la funci&oacute;n, una variable entre par&eacute;ntesis `()`, y el s&iacute;mbolo de dos puntos `:`. El siguiente c&oacute;digo, con un nivel adicional de indentaci&oacute;n, es el cuerpo de la funci&oacute;n."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def func0():   \n",
    "    print(\"test\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "test\n"
     ]
    }
   ],
   "source": [
    "func0()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En forma opcional, pero muy recomendada, podemos definir un \"docstring\", que es una descripci&oacute;n del prop&oacute;sito y comportamiento de la funci&oacute;n. El docstring deber&iacute;a ser incluido directamente despu&eacute;s de la definici&oacute;n de la funci&oacute;n, antes del c&oacute;digo en el cuerpo de la funci&oacute;n."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def func1(p):\n",
    "    \"\"\"\n",
    "    Imprime la cadena 's' y cu&aacute;ntos caracteres tiene\n",
    "    \n",
    "    \"\"\"\n",
    "    \n",
    "    print(p + \" tiene \" + str(len(p)) + \" caracteres\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function func1 in module __main__:\n",
      "\n",
      "func1(p)\n",
      "    Imprime la cadena 's' y cu&aacute;ntos caracteres tiene\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(func1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "test2 tiene 5 caracteres\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "func1(\"test2\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Funciones que retornan un valor usan la palabra clave `return`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "def cuadrado(x):\n",
    "    \"\"\"\n",
    "    Calcula el cuadrado de x.\n",
    "    \"\"\"\n",
    "    print(\"Calculando el cuadrado de x\")\n",
    "    b = x**2\n",
    "    return b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Calculando el cuadrado de x\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = 2\n",
    "c = cuadrado(b)\n",
    "c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos retornar m&uacute;ltiples valores desde una funci&oacute;n usando las tuplas (ver m&aacute;s arriba):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "def potencias(x):\n",
    "    \"\"\"\n",
    "    Calcula algunas potencias de x.\n",
    "    \"\"\"\n",
    "    return x**2, x**3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(9, 27)"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "potencias(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "x2, x3 = potencias(3)\n",
    "xp = potencias(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Argumentos por defecto y argumentos de palabra clave\n",
    "\n",
    "En la definici&oacute;n de una funci&oacute;n, podemos asignar valores por defecto a los argumentos de la funci&oacute;n:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mifunc(y, p=2, debug=False):\n",
    "    if debug:\n",
    "        print(\"evaluando mifunc para x = \" + str(y) + \" usando el exponente p = \" + str(p))\n",
    "    return y**p"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si no suministramos un valor para el argumento `debug` al llamar a la funci&oacute;n `mifunc` se considera el valor definido por defecto:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "18"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y = 3\n",
    "a = mifunc(y)\n",
    "\n",
    "c = a*2\n",
    "c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "evaluando mifunc para x = 5 usando el exponente p = 2\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "25"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mifunc(5, debug=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si listamos expl&iacute;citamente el nombre de los argumentos al llamar una funci&oacute;n, ellos no necesitan estar en el mismo orden usado en la definici&oacute;n de la funci&oacute;n. Esto es llamado argumentos *de palabra clave* (keyword), y son a menudo muy &uacute;tiles en funciones que requieren muchos argumentos opcionales."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "mifunc() got an unexpected keyword argument 'deg'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-49-63dae45bf210>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mmifunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mp\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdeg\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m7\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: mifunc() got an unexpected keyword argument 'deg'"
     ]
    }
   ],
   "source": [
    "mifunc(p=3, debug=True, x=7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Funciones sin nombre (funciones lambda)\n",
    "\n",
    "En Python podemos tambi&eacute;n crear funciones sin nombre, usando la palabra clave `lambda`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "f1 = lambda x: x**2\n",
    "    \n",
    "# es equivalente a \n",
    "\n",
    "def f2(x):\n",
    "    return x**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for ** or pow(): 'list' and 'int'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-59-e9238dbbb391>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0ma\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mf1\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-54-618454de930a>\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(x)\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mf1\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mlambda\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m**\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;31m# es equivalente a\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mf2\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for ** or pow(): 'list' and 'int'"
     ]
    }
   ],
   "source": [
    "a = [-3,-2,-1,0,1,2,3]\n",
    "f1(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Esta t&eacute;cnica es &uacute;til, por ejemplo, cuando queremos pasar una funci&oacute;n simple como argumento de otra funci&oacute;n, como en este caso:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<map at 0x795f74078910>"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# map es una funci&oacute;n predefinida en Python\n",
    "map(lambda x: x**2, range(-3,4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[9, 4, 1, 0, 1, 4, 9]"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# en Python 3 podemos usar `list(...)` para convertir la iteraci&oacute;n a una lista expl&iacute;cita\n",
    "list(map(lambda x: x**2, range(-3,4)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Clases\n",
    "\n",
    "Las clases son una caracter&iacute;stica clave de la programaci&oacute;n orientada al objeto. Una clase es una estructura para representar un objeto y las operaciones que pueden ser realizadas sobre el objeto. \n",
    "\n",
    "En Python una clase puede contener *atributos* (variables) y *m&eacute;todos* (funciones).\n",
    "\n",
    "En Python una clase es definida en forma similar a una funci&oacute;n, pero usando la palabra clave `class`, y la definici&oacute;n de la clase usualmente contiene algunas definiciones de m&eacute;todos (una funci&oacute;n en una clase).\n",
    "\n",
    "* Cada m&eacute;todo de una clase deber&iacute;a tener un argumento `self` como su primer argumento. Este objeto es una autoreferencia.\n",
    "\n",
    "* Algunos nombres de m&eacute;todos de clases tienen un significado especial, por ejemplo:\n",
    "\n",
    " * `__init__`: El nombre del m&eacute;todo que es invocado cuando el objeto es creado por primera vez.\n",
    " * `__str__` : Un m&eacute;todo que es invocado cuando se necesita una simple representaci&oacute;n de cadena de la clase, como por ejemplo cuando se imprime.\n",
    " * Existen muchos otros m&eacute;todos especiales, ver http://docs.python.org/2/reference/datamodel.html#special-method-names\n",
    " \n",
    "### Ejemplo: Puntos en 2D"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Punto:\n",
    "    \"\"\"\n",
    "    Clase simple para representar un punto en un sistema de coordenadas cartesiano bidimensional.\n",
    "    \"\"\"\n",
    "    \n",
    "    def __init__(self, x, y):\n",
    "        \"\"\"\n",
    "        Crea un nuevo punto en x, y.\n",
    "        \"\"\"\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "        \n",
    "    def traslada(self, dx, dy):\n",
    "        \"\"\"\n",
    "        Traslada el punto en dx y dy en las direcciones x e y respectivamente.\n",
    "        \"\"\"\n",
    "        self.x += dx\n",
    "        self.y += dy\n",
    "        \n",
    "    def __str__(self):\n",
    "        return \"Punto en [%f, %f]\" % (self.x, self.y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ahora creamos un \"Punto\", es decir, una instancia de la clase \"Punto\":"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "p1 = Punto(0,0) # esto invoca el m&eacute;todo __init__ en la clase Punto\n",
    "\n",
    "print(p1)         # esto invoca el m&eacute;todo __str__ "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(p1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si ahora ejecutamos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "p2 = Punto(1,1)\n",
    "\n",
    "p1.traslada(0.25,1.5)\n",
    "\n",
    "print(p1)\n",
    "print(p2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Estamos definiendo una nueva instancia (un nuevo \"punto\", asignado a la variable p2), y luego hemos \"invocado el m&eacute;todo `traslada` en la instancia `p1` de la clase punto\" lo que representa la acci&oacute;n de realizar una traslaci&oacute;n del punto p1."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note que llamar a m&eacute;todos de clases puede modificar el estado de esa instancia de clase particular, pero no afecta otras instancias de la clase o alguna otra variable global.\n",
    "\n",
    "Esto es una de las cosas buenas de un dise&ntilde;o orientado al objeto: c&oacute;digo como las funciones y variables relacionadas son agrupadas en entidades separadas e independientes. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## M&oacute;dulos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La mayor&iacute;a de la funcionalidad en Python es provista por *m&oacute;dulos*. La [*Librer&iacute;a Est&aacute;ndar*](https://docs.python.org/2/library/) de Python es una gran colecci&oacute;n de  m&oacute;dulos que proveen implementaciones *multiplataforma* de recursos tales como el acceso al sistema operativo, entrada/salido de archivos (file I/O), manejo de cadenas, comunicaci&oacute;n en redes, y mucho m&aacute;s.\n",
    "\n",
    "Para usar un m&oacute;dulo en un programa Python &eacute;ste debe primero ser **importado**, para lo cual se usa el comando `import`. Por ejemplo, para importar el m&oacute;dulo `math`, que contiene muchas funciones matem&aacute;ticas est&aacute;ndar, podemos usar:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Esto importa el m&oacute;dulo completo y lo deja disponible para su uso en el programa. Por ejemplo, podemos escribir:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "\n",
    "x = math.cos(2*math.pi)\n",
    "\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Alternativamente, podemos elegir importar todos los s&iacute;mbolos (funciones y variables) en un m&oacute;dulo al espacio de nombres (namespace) actual (de modo que no necesitemos usar el prefijo \"`math.`\" cada vez que usemos algo del m&oacute;dulo `math`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import *\n",
    "\n",
    "x = cos(2*pi)\n",
    "\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Esta forma de proceder puede ser muy conveniente, pero en programas largos que incluyen muchos m&oacute;dulos es a menudo una buena idea mantener los s&iacute;mbolos de cada m&oacute;dulo en sus propios espacios de nombres, usando `import math`. Esto elimina potenciales confusiones con eventuales colisiones de nombres, ya que no es poco com&uacute;n encontrar funciones o variables definidas con el mismo nombre en m&oacute;dulos distintos.\n",
    "\n",
    "Como alternativa intermedia, podemos importar un m&oacute;dulo con un *alias* o nombre abreviado:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math as m\n",
    "\n",
    "x = m.cos(2*m.pi)\n",
    "\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finalmente, podemos importar s&oacute;lo algunos s&iacute;mbolos seleccionados desde un m&oacute;dulo list&aacute;ndolos expl&iacute;citamente, en lugar de usar el car&aacute;cter comod&iacute;n `*`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import cos, pi\n",
    "\n",
    "x = cos(2*pi)\n",
    "\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  Mirando qu&eacute; contiene un m&oacute;dulo, y su documentaci&oacute;n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Luego que se ha cargado un m&oacute;dulo, podemos listar los s&iacute;mbolos que &eacute;ste provee usando la funci&oacute;n `dir`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "\n",
    "dir(math)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Usando la funci&oacute;n `help` podemos obtener una descripci&oacute;n de cada funci&oacute;n (casi... no todas las funciones tienen *docstrings*, como se les llama t&eacute;cnicamente. Sin embargo, la mayor&iacute;a de las funciones est&aacute;n documentadas de esta forma). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "help(math.log)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "log(10) # calcula el logaritmo de 10 en base e"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "log(10, 2) # calcula el logaritmo de 10 en base 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tambi&eacute;n podemos usar la funci&oacute;n `help` directamente sobre los m&oacute;dulos: \n",
    "\n",
    "    help(math) \n",
    "\n",
    "Algunos m&oacute;dulos muy &uacute;tiles de la librer&iacute;a est&aacute;ndar de Python son `os` (interfaz con el sistema operativo), `sys` (Par&aacute;metros y funciones espec&iacute;ficas del sistema), `math` (funciones matem&aacute;ticas), `shutil` (operaciones con archivos), `subprocess`, `multiprocessing`, `threading`. \n",
    "\n",
    "Una lista completa de los m&oacute;dulos est&aacute;ndar para Python 2 y Python 3 est&aacute; disponible (en ingl&eacute;s) en [http://docs.python.org/2/library/](http://docs.python.org/2/library/) y [http://docs.python.org/3/library/](http://docs.python.org/3/library/), respectivamente. Una versi&oacute;n en espa&ntilde;ol est&aacute; disponible en [http://pyspanishdoc.sourceforge.net/lib/lib.html](http://pyspanishdoc.sourceforge.net/lib/lib.html).\n",
    "\n",
    "Existen muchos otros m&oacute;dulos (paquetes) desarrollados para Python que implementan distintas funcionalidades, herramientas y algoritmos. Muchos de ellos son constantemente desarrollados en forma abierta por comunidades de usuari@s interesad@s.\n",
    "\n",
    " Aqu&iacute; listamos algunos m&oacute;dulos generales &uacute;tiles en el &aacute;mbito de las ciencias (F&iacute;sicas):\n",
    " \n",
    " * [Numpy](http://www.numpy.org/): Implementa el uso eficiente de arreglos num&eacute;ricos multidimensionales (vectores, matrices, etc.).\n",
    " * [Scipy](http://www.scipy.org/): Implementa m&uacute;ltiples funciones especiales, algoritmos de integraci&oacute;n num&eacute;rica, optimizaci&oacute;n, interpolaci&oacute;n, transformada de Fourier, procesamiento de se&ntilde;ales, &aacute;lgebra lineal, estad&iacute;stica, procesamiento de im&aacute;genes, entre otras. Este m&oacute;dulo hace uso de Numpy.\n",
    " * [Matplotlib](http://matplotlib.org/): Suministra herramientas para crear gr&aacute;ficos bidimensionales en diversos formatos, y en una calidad adecuada para incluirlos en publicaciones cient&iacute;ficas.\n",
    " * [Sympy](http://sympy.org/): Paquete que implementa algoritmos de matem&aacute;tica simb&oacute;lica.\n",
    " \n",
    " Adem&aacute;s de estos paquetes principales (m&aacute;s usados) cabe la pena mencionar a:\n",
    "  \n",
    "* [Sunpy](http://sunpy.org/): M&oacute;dulo para el an&aacute;lisis de datos relacionados con la f&iacute;sica solar.\n",
    "* [EMpy](http://sunpy.org/): Suministra algoritmos num&eacute;ricos usados en electromagnetismo.\n",
    "* [Mpmath](http://mpmath.org/): M&oacute;dulo con herramientas para c&aacute;lculos con valores reales y complejos con precisi&oacute;n arbitraria.\n",
    "* [Poliastro](http://poliastro.readthedocs.io/en/latest/):  Conjunto de rutinas Python &uacute;tiles en astrodin&aacute;mica y mec&aacute;nica orbital.\n",
    "* [Fatiando a Terra](http://fatiando.org/): Conjunto de herramientas para la modelaci&oacute;n de fen&oacute;menos geof&iacute;sicos.\n",
    "* [ArcPy](http://pro.arcgis.com/en/pro-app/arcpy/get-started/what-is-arcpy-.htm). M&oacute;dulo que provee heramientas para an&aacute;lisis, conversi&oacute;n y manejo de datos geogr&aacute;ficos, y de automatizaci&oacute;n de mapas.\n",
    "* [Qutip2](http://qutip.org/):  Paquete de herramientas para simular la din&aacute;mica de sistemas cu&aacute;nticos abiertos.\n",
    "* [Yt](http://yt-project.org/): Paquete para el an&aacute;lisis y visualizaci&oacute;n de datos volum&eacute;tricos.\n",
    "* [Fipy](http://www.ctcms.nist.gov/fipy/): Implementa algoritmos para resolver ecuaciones diferenciales parciales (EDP) por medio de m&eacute;todos de vol&uacute;menes finitos.\n",
    "* [Holopy](http://manoharan.seas.harvard.edu/holopy/): Herramientas para el trabajo con hologramas digitales y scattering de luz.\n",
    "* [Astropy](http://www.astropy.org/): M&oacute;dulo que implementa herramientas de uso com&uacute;n en Astronom&iacute;a.\n",
    "* [Galpy](http://galpy.readthedocs.io/en/latest/): M&oacute;dulo para Din&aacute;mica Gal&aacute;ctica.\n",
    "* [AstroML](http://www.astroml.org/) M&oacute;dulo con herramientas de \"machine learning\" y \"data mining\" de datos astron&oacute;micos, basado en Numpy, Scipy, Scikit-Learn, Matplotlib y Astropy.\n",
    "* [Librosa](http://librosa.github.io/librosa/): M&oacute;dulo para an&aacute;lisis de audio y m&uacute;sica.\n",
    "* [Scikit-learn](http://scikit-learn.org/): Implementa funciones de \"Machine Learning\" (Clasificaci&oacute;n, Regresi&oacute;n, Clustering, reducci&oacute;n dimensional, Selecci&oacute;n de Modelos, etc.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creaci&oacute;n de M&oacute;dulos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Uno de los conceptos m&aacute;s importantes en programaci&oacute;n es el de reusar c&oacute;digo para evitar repeticiones.\n",
    "\n",
    "La idea es escribir funciones y clases con un prop&oacute;sito y extensi&oacute;n bien definidos, y reusarlas en lugar de repetir c&oacute;digo similar en diferentes partes del programa (programaci&oacute;n modular). Usualmente el resultado es que se mejora ostensiblemente la facilidad de lectura y de mantenci&oacute;n de un programa. En la pr&aacute;ctica, esto significa que nuestro programa tendr&aacute; menos errores, y ser&aacute;n m&aacute;s f&aacute;ciles de extender y corregir. \n",
    "\n",
    "Python permite programaci&oacute;n modular en diferentes niveles. Las funciones y las clases son ejemplos de herramientas para programaci&oacute;n modular de bajo nivel. Los m&oacute;dulos Python son construcciones de programaci&oacute;n modular de m&aacute;s alto nivel, donde podemos colectar variables relacionadas, funciones y clases. Un m&oacute;dulo Python es definido en un archivo Python (con extensi&oacute;n `.py`), y puede ser accequible a otros m&oacute;dulos Python y a programas usando el comendo `import`. \n",
    "\n",
    "Considere el siguiente ejemplo: el archivo `mimodulo.py` contiene una implementaci&oacute;n simple de una variable, una funci&oacute;n y una clase:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos importar el m&oacute;dulo `mimodulo` a un programa Python usando `import`,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import mimodulo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "y usar `help(module)` para obtener un resumen de lo que suministra el m&oacute;dulo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "help(mimodulo)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mimodulo.mi_variable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mimodulo.mi_function() "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mi_clase = mimodulo.MiClase() \n",
    "mi_clase.set_variable(10)\n",
    "mi_clase.get_variable()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si hacemos cambios en el c&oacute;digo de `mimodulo.py`, necesitamos recargarlo usando `reload`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "reload(mimodulo)  # s&oacute;lo funciona en Python 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Excepciones\n",
    "\n",
    "En Python los errores son manejados con una construcci&oacute;n especial de lenguaje llamada \"Exceptions\" (excepciones). Cuando ocurre un error, una excepci&oacute;n puede ser hecha, que interrumpe el flujo normal del programa y retorna a alg&uacute;n otro lugar del c&oacute;digo donde se definan los comandos try-except m&aacute;s cercanos.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para generar una excepci&oacute;n podemos usar el comando `raise`, que toma un argumento que debe ser una instancia de la clase  `BaseExpection` o una clase derivada de ella. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "raise Exception(\"descripci&oacute;n del error\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Un uso t&iacute;pico de las excepciones es para abortar funciones cuando ocurre alg&uacute;n error, por ejemplo:\n",
    "\n",
    "    def mi_funcion(argumentos):\n",
    "    \n",
    "        if not verify(argumentos):\n",
    "            raise Expection(\"Argumentos invalidos\")\n",
    "        \n",
    "        # el resto del c&oacute;digo sigue aqu&iacute;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para capturar los errores que son generados por funciones y m&eacute;todos de clases, o por el mismo int&eacute;rprete Python, use los comandos `try` y `except`:\n",
    "\n",
    "    try:\n",
    "        # aqu&iacute; va el c&oacute;digo normal\n",
    "    except:\n",
    "        # el c&oacute;digo para manejar el error va aqu&iacute;\n",
    "        # Este c&oacute;digo no se ejecuta a menos que \n",
    "        # el c&oacute;digo de arriba genere un error\n",
    "\n",
    "Por ejemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    print(\"test\")\n",
    "    # genera un error: ya que la variable test no est&aacute; definida\n",
    "    print(test)\n",
    "except:\n",
    "    print(\"Encontr&eacute; una excepci&oacute;n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para obtener informaci&oacute;n sobre un error, podemos accesar la instancia de clase `Exception` que describe la excepci&oacute;n usando por ejemplo:\n",
    "\n",
    "    except Exception as e:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    print(\"test\")\n",
    "    # genera un error: ya que la variable test no est&aacute; definida\n",
    "    print(test)\n",
    "except Exception as e:\n",
    "    print(\"Encontr&eacute; una excepci&oacute;n:\" + str(e))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lectura adicional\n",
    "\n",
    "* [http://www.python.org](http://www.python.org) - The official web page of the Python programming language.\n",
    "* [http://www.python.org/dev/peps/pep-0008](http://www.python.org/dev/peps/pep-0008) - Gu&iacute;a de estilo para la programaci&oacute;n en Python. Altamente recomendada (en ingl&eacute;s).\n",
    "* [http://www.greenteapress.com/thinkpython/](http://www.greenteapress.com/thinkpython/) - Un libro gratuito sobre Python.\n",
    "* [Python Essential Reference](http://www.amazon.com/Python-Essential-Reference-4th-Edition/dp/0672329786) - Un buen libro de referencia sobre programaci&oacute;n en Python."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Versiones"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "import IPython"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Este notebook fue evaluado con: Python %s y IPython %s.\" % (sys.version, IPython.__version__))"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}