00_01_Introduccion-a-la-Programacion-en-Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introducción a la programación en Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Versión original en inglé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 última versión de estos [Notebooks](http://ipython.org/notebook.html) está disponible en [http://github.com/gfrubi/clases-python-cientifico](http://github.com/gfrubi/clases-python-cientifico).\n",
    "\n",
    "La última versión del original (en inglés) está disponible en [http://github.com/jrjohansson/scientific-python-lectures](http://github.com/jrjohansson/scientific-python-lectures).\n",
    "Los otros notebooks de esta serie está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ódigo Python es usualmente almacenado en archivos de texto con extensión \"`.py`\" (un \"script\"):\n",
    "\n",
    "        miprograma.py\n",
    "\n",
    "* Se asume que cada línea de un archivo de programa en Python es una sentencia Python, o parte de una sentencia. \n",
    "\n",
    "    * La única excepción son las líneas de comentarios, que comienzan con el caracter `#` (opcionalmente precedida por un número arbitrario de caracteres de espacio en blanco, es decir, tabs y espacios. Las líneas de comentarios son usualmente ignoradas por el intérprete Python.\n",
    "\n",
    "\n",
    "* Para ejecutar nuestro programa Python desde la línea de comando usamos:\n",
    "\n",
    "        $ python miprograma.py\n",
    "\n",
    "* En sistemas UNIX es común definir la ruta al intérprete en la primera línea del programa (note que ésta es una línea de comentarios en lo que respecta al inté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ón de caracteres"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La codificación estándar de caracteres es la ASCII, pero podemos usar cualquier otra codificación, por ejemplo UTF-8. Para especificar que usamos UTF-8 incluimos la línea especial\n",
    "\n",
    "    # -*- coding: UTF-8 -*-\n",
    "\n",
    "al comienzo del archivo."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Aparte de estas dos líneas *opcionales* al comienzo de un archivo Python, no se requiere de otro código adicional para inicializar un programa. Por otro lado, en la versión 3 de Python ya no es necesario agregar có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ón estándar de có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ódigo Python, y có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ó antes. Aparte de eso, no hay diferencia entre el có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í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ón, los nombres de las variables comienzan con letra minúscula, mientras que los nombres de las clases comienzan con una letra mayúscula. \n",
    "\n",
    "Además, existen algunos palabras claves Python que no pueden ser usados como nombres de variables. É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ón con la palabra `lambda`, que podría fácilmente ser un nombre de variable natural en un programa cientí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á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": 1,
   "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ícitamente, cada variable sí tiene un tipo asociada a ella. El tipo es extraido del valor que le fue asignado."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "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": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "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": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "#print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tipos Fundamentales"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# enteros\n",
    "x = 1\n",
    "type(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# flotantes\n",
    "x = 1.0\n",
    "type(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "bool"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# booleanos\n",
    "b1 = True\n",
    "b2 = False\n",
    "\n",
    "type(b1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "complex"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# nú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": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1-1j)\n"
     ]
    }
   ],
   "source": [
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.0 -1.0\n"
     ]
    }
   ],
   "source": [
    "print(x.real, x.imag)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 1.0\n",
    "\n",
    "# verifica si la variable x es flotante\n",
    "type(x) is float"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# verifica si la variable x es un entero\n",
    "type(x) is int"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos también usar el método `isinstance` para testear tipos de variables:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "isinstance(x, float)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Conversión de Tipo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.5 <class 'float'>\n"
     ]
    }
   ],
   "source": [
    "x = 1.5\n",
    "\n",
    "print(x, type(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 <class 'int'>\n"
     ]
    }
   ],
   "source": [
    "x = int(x)\n",
    "\n",
    "print(x, type(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1+0j) <class 'complex'>\n"
     ]
    }
   ],
   "source": [
    "z = complex(x)\n",
    "\n",
    "print(z, type(z))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "#x = float(z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Un número complejo no puede ser convertido a un número flotante o a un entero. Necesitamos usar `z.real`, o bien `z.imag`, para extraer la parte que deseamos del número complejo z:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.0  ->  True <class 'bool'>\n",
      "0.0  ->  False <class 'bool'>\n"
     ]
    }
   ],
   "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ía de los operadores y las comparaciones en Python funcionan como se esperaría:\n",
    "\n",
    "* Operadores aritméticos `+`, `-`, `*`, `/`, `//` (división entera), '**' potencia\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, -1, 2, 0.5)"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 + 2, 1 - 2, 1 * 2, 1 / 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3.0, -1.0, 2.0, 0.5)"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1.0 + 2.0, 1.0 - 2.0, 1.0 * 2.0, 1.0 / 2.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# División entera de dos númenos flotantes\n",
    "3.0 // 2.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Atenció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": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "True and False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "not False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "True or False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Operadores de comparación `>`, `<`, `>=` (mayor o igual), `<=` (menor o igual), `==` igualdad, `es` idéntico."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(True, False)"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 > 1, 2 < 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(False, False)"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 > 2, 2 < 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(True, True)"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 >= 2, 2 <= 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# igualdad\n",
    "[1,2] == [1,2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# ¿objetos idé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": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = \"Hola mundo\"\n",
    "type(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# longitud de la cadena: el número de caracteres que contiene\n",
    "len(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hola universo\n"
     ]
    }
   ],
   "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ácter en una cadena usando `[]`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'H'"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Atenció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 índices  `desde` y `hasta` **sin incluir el elemento con índice `hasta'**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hola '"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "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": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hola '"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[:5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'undo'"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[6:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hola mundo'"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos también definir el tamañ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": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hola mundo'"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[::1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hl ud'"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[::2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Esta técnica es llamada *slicing* (\"rebanado\"). Puede leer más sobre la sintaxis [aquí](http://pyspanishdoc.sourceforge.net/lib/built-in-funcs.html) y [aquí](http://docs.python.org/release/2.7.3/library/functions.html?highlight=slice#slice) (en inglés)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python tiene un rico conjunto de funciones para procesar texto. Ver por ejemplo la documentación en [este link](http://docs.python.org/2/library/string.html) (en inglés) para más información."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Ejemplos de formateo de cadenas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "uno dos tres\n"
     ]
    }
   ],
   "source": [
    "print(\"uno\", \"dos\", \"tres\")  # El comando print puede desplegar varias cadenas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "uno 1.0 False (-0-1j)\n"
     ]
    }
   ],
   "source": [
    "print(\"uno\", 1.0, False, -1j)  # El comando print convierte todos los argumentos a cadenas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "unodostres\n"
     ]
    }
   ],
   "source": [
    "print(\"uno\" + \"dos\" + \"tres\") # cadenas \"sumadas\" con + son contatenadas sin espacio entre ellas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "valor = 1.0\n"
     ]
    }
   ],
   "source": [
    "print(\"valor = \"+str(1.0)) # podemos transformar un float a string y concatenarlos en la salida"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "valor = 1.000000\n"
     ]
    }
   ],
   "source": [
    "print(\"valor = %f\" % 1.0) # podemos usar formateo de cadenas en el estilo del lenguaje C"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "valor1 = 3.14. valor2 = 1\n"
     ]
    }
   ],
   "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": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "valor1 = 3.1415, valor2 = 1.5\n"
     ]
    }
   ],
   "source": [
    "# forma alternativa, má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": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'list'>\n",
      "[1, 2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "l = [1,2,3,4]\n",
    "\n",
    "print(type(l))\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos usar las mismas técnicas de \"rebanado\" que usamos en el caso de cadenas para manipular listas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4]\n",
      "[2, 3]\n",
      "[1, 3]\n"
     ]
    }
   ],
   "source": [
    "print(l)\n",
    "\n",
    "print(l[1:3])\n",
    "\n",
    "print(l[::2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Atención usuarios de MATLAB:** el indexado comienza en 0!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Los elementos en una lista no requieren ser del mismo tipo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 'a', 1.0, (1-1j)]\n"
     ]
    }
   ],
   "source": [
    "l = [1, 'a', 1.0, 1-1j]\n",
    "\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Las listas en Python pueden ser *inhomogéneas* y *arbitrariamente anidadas*:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, [2, [3, [4, [5]]]]]"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "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ás abajo). Existen muchas funciones convenientes para generar listas de varios tipos, por ejemplo la función `range`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "range(10, 30, 2)"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "desde = 10\n",
    "hasta = 30\n",
    "paso = 2\n",
    "\n",
    "range(desde, hasta, paso)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[10, 12, 14, 16, 18, 20, 22, 24, 26, 28]"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "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": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[-10, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(range(-10, 10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hola mundo'"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['H', 'o', 'l', 'a', ' ', 'm', 'u', 'n', 'd', 'o']"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# convierte una cadena a una lista, por conversión de tipo:\n",
    "\n",
    "s2 = list(s)\n",
    "\n",
    "s2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[' ', 'H', 'a', 'd', 'l', 'm', 'n', 'o', 'o', 'u']\n"
     ]
    }
   ],
   "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": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['A', 'd', 'd']\n"
     ]
    }
   ],
   "source": [
    "# crea una nueva lista vací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écnico se dice que la lista es *mutable*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['A', 'p', 'p']\n"
     ]
    }
   ],
   "source": [
    "l[1] = \"p\"\n",
    "l[2] = \"p\"\n",
    "\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['A', 'd', 'd']\n"
     ]
    }
   ],
   "source": [
    "l[1:3] = [\"d\", \"d\"]\n",
    "\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Insertar un elemento en una posición específica `insert`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['i', 'n', 's', 'e', 'r', 't', 'A', 'd', 'd']\n"
     ]
    }
   ],
   "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ífico usando 'remove'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['i', 'n', 's', 'e', 'r', 't', 'd', 'd']\n"
     ]
    }
   ],
   "source": [
    "l.remove(\"A\")\n",
    "\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Eliminar un elemento en una posición específica usando `del`:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Puede introducir `help(list)` para más detalles, o leer la documentació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": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(10, 20) <class 'tuple'>\n"
     ]
    }
   ],
   "source": [
    "punto = (10, 20)\n",
    "\n",
    "print(punto, type(punto))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(10, 20) <class 'tuple'>\n"
     ]
    }
   ],
   "source": [
    "punto = 10, 20\n",
    "\n",
    "print(punto, type(punto))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos separar una tupla asignándola a una lista de variables separadas por coma:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x = 10\n",
      "y = 20\n"
     ]
    }
   ],
   "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": 68,
   "metadata": {},
   "outputs": [],
   "source": [
    "#punto[0] = 20"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Diccionarios\n",
    "\n",
    "Los diccionarios son tambié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": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'dict'>\n",
      "{'clave1': 1.0, 'clave2': True, 'clave3': 'hola'}\n"
     ]
    }
   ],
   "source": [
    "parametros = {\"clave1\" : 1.0, \"clave2\" : True, \"clave3\" : \"hola\"}\n",
    "\n",
    "print(type(parametros))\n",
    "print(parametros)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "parametros[\"clave1\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "clave1 --> 1.0\n",
      "clave2 --> True\n",
      "clave3 --> hola\n"
     ]
    }
   ],
   "source": [
    "print(\"clave1 --> \" + str(parametros[\"clave1\"]))\n",
    "print(\"clave2 --> \" + str(parametros[\"clave2\"]))\n",
    "print(\"clave3 --> \" + str(parametros[\"clave3\"]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "clave1 = A\n",
      "clave2 = False\n",
      "clave3 = hola\n",
      "clave4 = D\n"
     ]
    }
   ],
   "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ón condicional de código usa las palabras clave `if`, `elif` (else if), `else`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "afirmacion1 y afirmacion2 son falsas\n"
     ]
    }
   ],
   "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í encontramos por primera vez un aspecto pecular e inusual del lenguaje Python: Los bloques del programa son definidos por su nivel de indentación (la cantidad de espacio antes de cada linea). \n",
    "\n",
    "Compare con el có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éntesis llaves `{` y `}`. El nivel de indentación (espacio en blanco antes del código) no importa (es completamente opcional). \n",
    "\n",
    "En Python, la extensión de un bloque de código es definido por el nivel de indentación (usualmente un tab o cuatro espacios en blanco). Esto significa que debemos ser cuidados@s de indentar nuestro código correctamente, de lo contrario tendremos errores de sintaxis. Además, pueden presentarse errores en la ejecució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": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tanto afirmacion1 como afirmacion2 son verdaderas\n"
     ]
    }
   ],
   "source": [
    "afirmacion1 = afirmacion2 = True\n",
    "\n",
    "if afirmacion1:\n",
    "    if afirmacion2:\n",
    "        print(\"tanto afirmacion1 como afirmacion2 son verdaderas\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Mala indentación!\n",
    "#if afirmacion1:\n",
    "#    if afirmacion2:\n",
    "#    print(\"tanto afirmacion1 como afirmacion2 son verdaderas\")  # esta línea está mal indentada"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "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": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ahora estamos fuera del bloque\n"
     ]
    }
   ],
   "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ás común es usando un ciclo `for`, que se usa junto con objetos iterables, como por ejemplos las listas. La sintaxis básica es:\n",
    "\n",
    "\n",
    "**Ciclos `for`**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "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": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "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": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-3\n",
      "-2\n",
      "-1\n",
      "0\n",
      "1\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "for x in range(-3,3):\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "computación\n",
      "científica\n",
      "con\n",
      "Python\n"
     ]
    }
   ],
   "source": [
    "for palabra in [\"computación\", \"cientí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": 82,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "clave1 = A\n",
      "clave2 = False\n",
      "clave3 = hola\n",
      "clave4 = D\n"
     ]
    }
   ],
   "source": [
    "for clave, valor in parametros.items():\n",
    "    print(clave + \" = \" + str(valor))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Algunas veces es útil tener acceso a los índices de los valores mientras se itera sobre una lista. Podemos usar la función `enumerate` para esto:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 -3\n",
      "1 -2\n",
      "2 -1\n",
      "3 0\n",
      "4 1\n",
      "5 2\n"
     ]
    }
   ],
   "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": 84,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 4, 9, 16]\n"
     ]
    }
   ],
   "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": 85,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "listo\n"
     ]
    }
   ],
   "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ón."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Funciones\n",
    "\n",
    "En Python una función es definida usando la palabra clave `def`, seguida de un nombre para la función, una variable entre paréntesis `()`, y el símbolo de dos puntos `:`. El siguiente código, con un nivel adicional de indentación, es el cuerpo de la función."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [],
   "source": [
    "def func0():   \n",
    "    print(\"test\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "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ón del propósito y comportamiento de la función. El docstring debería ser incluido directamente después de la definición de la función, antes del código en el cuerpo de la función."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [],
   "source": [
    "def func1(s):\n",
    "    \"\"\"\n",
    "    Imprime la cadena 's' y cuántos caracteres tiene\n",
    "    \"\"\"\n",
    "    \n",
    "    print(s + \" tiene \" + str(len(s)) + \" caracteres\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function func1 in module __main__:\n",
      "\n",
      "func1(s)\n",
      "    Imprime la cadena 's' y cuántos caracteres tiene\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(func1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "test tiene 4 caracteres\n"
     ]
    }
   ],
   "source": [
    "func1(\"test\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Funciones que retornan un valor usan la palabra clave `return`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [],
   "source": [
    "def cuadrado(x):\n",
    "    \"\"\"\n",
    "    Calcula el cuadrado de x.\n",
    "    \"\"\"\n",
    "    return x**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "16"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cuadrado(4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos retornar múltiples valores desde una función usando las tuplas (ver más arriba):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [],
   "source": [
    "def potencias(x):\n",
    "    \"\"\"\n",
    "    Calcula algunas potencias de x.\n",
    "    \"\"\"\n",
    "    return x**2, x**3, x**4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(9, 27, 81)"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "potencias(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "27\n"
     ]
    }
   ],
   "source": [
    "x2, x3, x4 = potencias(3)\n",
    "\n",
    "print(x3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Argumentos por defecto y argumentos de palabra clave\n",
    "\n",
    "En la definición de una función, podemos asignar valores por defecto a los argumentos de la función:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mifunc(x, p=2, debug=False):\n",
    "    if debug:\n",
    "        print(\"evaluando mifunc para x = \" + str(x) + \" usando el exponente p = \" + str(p))\n",
    "    return x**p"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si no suministramos un valor para el argumento `debug` al llamar a la función `mifunc` se considera el valor definido por defecto:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "25"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mifunc(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "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": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mifunc(5, debug=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si listamos explícitamente el nombre de los argumentos al llamar una función, ellos no necesitan estar en el mismo orden usado en la definición de la función. Esto es llamado argumentos *de palabra clave* (keyword), y son a menudo muy útiles en funciones que requieren muchos argumentos opcionales."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "evaluando mifunc para x = 7 usando el exponente p = 3\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "343"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mifunc(p=3, debug=True, x=7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Funciones sin nombre (funciones lambda)\n",
    "\n",
    "En Python podemos también crear funciones sin nombre, usando la palabra clave `lambda`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "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": 101,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(4, 4)"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f1(2), f2(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Esta técnica es útil, por ejemplo, cuando queremos pasar una función simple como argumento de otra función, como en este caso:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<map at 0x2129ee73668>"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# map es una función predefinida en Python\n",
    "map(lambda x: x**2, range(-3,4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[9, 4, 1, 0, 1, 4, 9]"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# en Python 3 podemos usar `list(...)` para convertir la iteración a una lista explícita\n",
    "list(map(lambda x: x**2, range(-3,4)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Clases\n",
    "\n",
    "Las clases son una característica clave de la programació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étodos* (funciones).\n",
    "\n",
    "En Python una clase es definida en forma similar a una función, pero usando la palabra clave `class`, y la definición de la clase usualmente contiene algunas definiciones de métodos (una función en una clase).\n",
    "\n",
    "* Cada método de una clase debería tener un argumento `self` como su primer argumento. Este objeto es una autoreferencia.\n",
    "\n",
    "* Algunos nombres de métodos de clases tienen un significado especial, por ejemplo:\n",
    "\n",
    " * `__init__`: El nombre del método que es invocado cuando el objeto es creado por primera vez.\n",
    " * `__str__` : Un método que es invocado cuando se necesita una simple representación de cadena de la clase, como por ejemplo cuando se imprime.\n",
    " * Existen muchos otros mé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": 104,
   "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": 105,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Punto en [0.000000, 0.000000]\n"
     ]
    }
   ],
   "source": [
    "p1 = Punto(0,0) # esto invoca el método __init__ en la clase Punto\n",
    "\n",
    "print(p1)         # esto invoca el método __str__ "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "__main__.Punto"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(p1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si ahora ejecutamos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Punto en [0.250000, 1.500000]\n",
      "Punto en [1.000000, 1.000000]\n"
     ]
    }
   ],
   "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étodo `traslada` en la instancia `p1` de la clase punto\" lo que representa la acción de realizar una traslación del punto p1."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note que llamar a mé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ño orientado al objeto: código como las funciones y variables relacionadas son agrupadas en entidades separadas e independientes. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Módulos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La mayoría de la funcionalidad en Python es provista por *módulos*. La [*Librería Estándar*](https://docs.python.org/2/library/) de Python es una gran colección de  mó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ón en redes, y mucho más.\n",
    "\n",
    "Para usar un módulo en un programa Python éste debe primero ser **importado**, para lo cual se usa el comando `import`. Por ejemplo, para importar el módulo `math`, que contiene muchas funciones matemáticas estándar, podemos usar:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Esto importa el módulo completo y lo deja disponible para su uso en el programa. Por ejemplo, podemos escribir:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.0\n"
     ]
    }
   ],
   "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ímbolos (funciones y variables) en un módulo al espacio de nombres (namespace) actual (de modo que no necesitemos usar el prefijo \"`math.`\" cada vez que usemos algo del módulo `math`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.0\n"
     ]
    }
   ],
   "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ódulos es a menudo una buena idea mantener los símbolos de cada mó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ún encontrar funciones o variables definidas con el mismo nombre en módulos distintos.\n",
    "\n",
    "Como alternativa intermedia, podemos importar un módulo con un *alias* o nombre abreviado:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.0\n"
     ]
    }
   ],
   "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ólo algunos símbolos seleccionados desde un módulo listándolos explícitamente, en lugar de usar el carácter comodín `*`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.0\n"
     ]
    }
   ],
   "source": [
    "from math import cos, pi\n",
    "\n",
    "x = cos(2*pi)\n",
    "\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  Mirando qué contiene un módulo, y su documentación"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Luego que se ha cargado un módulo, podemos listar los símbolos que éste provee usando la función `dir`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['__doc__',\n",
       " '__loader__',\n",
       " '__name__',\n",
       " '__package__',\n",
       " '__spec__',\n",
       " 'acos',\n",
       " 'acosh',\n",
       " 'asin',\n",
       " 'asinh',\n",
       " 'atan',\n",
       " 'atan2',\n",
       " 'atanh',\n",
       " 'ceil',\n",
       " 'copysign',\n",
       " 'cos',\n",
       " 'cosh',\n",
       " 'degrees',\n",
       " 'e',\n",
       " 'erf',\n",
       " 'erfc',\n",
       " 'exp',\n",
       " 'expm1',\n",
       " 'fabs',\n",
       " 'factorial',\n",
       " 'floor',\n",
       " 'fmod',\n",
       " 'frexp',\n",
       " 'fsum',\n",
       " 'gamma',\n",
       " 'gcd',\n",
       " 'hypot',\n",
       " 'inf',\n",
       " 'isclose',\n",
       " 'isfinite',\n",
       " 'isinf',\n",
       " 'isnan',\n",
       " 'ldexp',\n",
       " 'lgamma',\n",
       " 'log',\n",
       " 'log10',\n",
       " 'log1p',\n",
       " 'log2',\n",
       " 'modf',\n",
       " 'nan',\n",
       " 'pi',\n",
       " 'pow',\n",
       " 'radians',\n",
       " 'remainder',\n",
       " 'sin',\n",
       " 'sinh',\n",
       " 'sqrt',\n",
       " 'tan',\n",
       " 'tanh',\n",
       " 'tau',\n",
       " 'trunc']"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "dir(math)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Usando la función `help` podemos obtener una descripción de cada función (casi... no todas las funciones tienen *docstrings*, como se les llama técnicamente. Sin embargo, la mayoría de las funciones están documentadas de esta forma). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function log in module math:\n",
      "\n",
      "log(...)\n",
      "    log(x, [base=math.e])\n",
      "    Return the logarithm of x to the given base.\n",
      "    \n",
      "    If the base not specified, returns the natural logarithm (base e) of x.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(math.log)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.302585092994046"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "log(10) # calcula el logaritmo de 10 en base e"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.3219280948873626"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "log(10, 2) # calcula el logaritmo de 10 en base 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "También podemos usar la función `help` directamente sobre los módulos: \n",
    "\n",
    "    help(math) \n",
    "\n",
    "Algunos módulos muy útiles de la librería estándar de Python son `os` (interfaz con el sistema operativo), `sys` (Parámetros y funciones específicas del sistema), `math` (funciones matemáticas), `shutil` (operaciones con archivos), `subprocess`, `multiprocessing`, `threading`. \n",
    "\n",
    "Una lista completa de los módulos estándar para Python 2 y Python 3 está disponible (en inglé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ón en español está disponible en [http://pyspanishdoc.sourceforge.net/lib/lib.html](http://pyspanishdoc.sourceforge.net/lib/lib.html).\n",
    "\n",
    "Existen muchos otros mó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í listamos algunos módulos generales útiles en el ámbito de las ciencias (Físicas):\n",
    " \n",
    " * [Numpy](http://www.numpy.org/): Implementa el uso eficiente de arreglos numéricos multidimensionales (vectores, matrices, etc.).\n",
    " * [Scipy](http://www.scipy.org/): Implementa múltiples funciones especiales, algoritmos de integración numérica, optimización, interpolación, transformada de Fourier, procesamiento de señales, álgebra lineal, estadística, procesamiento de imágenes, entre otras. Este módulo hace uso de Numpy.\n",
    " * [Matplotlib](http://matplotlib.org/): Suministra herramientas para crear gráficos bidimensionales en diversos formatos, y en una calidad adecuada para incluirlos en publicaciones científicas.\n",
    " * [Sympy](http://sympy.org/): Paquete que implementa algoritmos de matemática simbólica.\n",
    " \n",
    " Además de estos paquetes principales (más usados) cabe la pena mencionar a:\n",
    "  \n",
    "* [Sunpy](http://sunpy.org/): Módulo para el análisis de datos relacionados con la física solar.\n",
    "* [EMpy](http://sunpy.org/): Suministra algoritmos numéricos usados en electromagnetismo.\n",
    "* [Mpmath](http://mpmath.org/): Módulo con herramientas para cálculos con valores reales y complejos con precisión arbitraria.\n",
    "* [Poliastro](http://poliastro.readthedocs.io/en/latest/):  Conjunto de rutinas Python útiles en astrodinámica y mecánica orbital.\n",
    "* [Fatiando a Terra](http://fatiando.org/): Conjunto de herramientas para la modelación de fenómenos geofísicos.\n",
    "* [Qutip2](http://qutip.org/):  Paquete de herramientas para simular la dinámica de sistemas cuánticos abiertos.\n",
    "* [Yt](http://yt-project.org/): Paquete para el análisis y visualización de datos volumétricos.\n",
    "* [Fipy](http://www.ctcms.nist.gov/fipy/): Implementa algoritmos para resolver ecuaciones diferenciales parciales (EDP) por medio de métodos de volú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ódulo que implementa herramientas de uso común en Astronomía.\n",
    "* [Librosa](http://librosa.github.io/librosa/): Módulo para análisis de audio y música.\n",
    "* [Scikit-learn](http://scikit-learn.org/): Implementa funciones de \"Machine Learning\" (Clasificación, Regresión, Clustering, reducción dimensional, Selección de Modelos, etc.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creación de Módulos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Uno de los conceptos más importantes en programación es el de reusar código para evitar repeticiones.\n",
    "\n",
    "La idea es escribir funciones y clases con un propósito y extensión bien definidos, y reusarlas en lugar de repetir código similar en diferentes partes del programa (programación modular). Usualmente el resultado es que se mejora ostensiblemente la facilidad de lectura y de mantención de un programa. En la práctica, esto significa que nuestro programa tendrá menos errores, y serán más fáciles de extender y corregir. \n",
    "\n",
    "Python permite programación modular en diferentes niveles. Las funciones y las clases son ejemplos de herramientas para programación modular de bajo nivel. Los módulos Python son construcciones de programación modular de más alto nivel, donde podemos colectar variables relacionadas, funciones y clases. Un módulo Python es definido en un archivo Python (con extensión `.py`), y puede ser accequible a otros módulos Python y a programas usando el comendo `import`. \n",
    "\n",
    "Considere el siguiente ejemplo: el archivo `mimodulo.py` contiene una implementación simple de una variable, una función y una clase:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos importar el módulo `mimodulo` a un programa Python usando `import`,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [],
   "source": [
    "import mimodulo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "y usar `help(module)` para obtener un resumen de lo que suministra el módulo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on module mimodulo:\n",
      "\n",
      "NAME\n",
      "    mimodulo\n",
      "\n",
      "DESCRIPTION\n",
      "    Ejemplo de un módulo Python. Contiene una variable llamada mi_variable,\n",
      "    una función llamada mi_function, y una clase llamada MiClase.\n",
      "\n",
      "CLASSES\n",
      "    builtins.object\n",
      "        MiClase\n",
      "    \n",
      "    class MiClase(builtins.object)\n",
      "     |  Clase ejemplo.\n",
      "     |  \n",
      "     |  Methods defined here:\n",
      "     |  \n",
      "     |  __init__(self)\n",
      "     |      Initialize self.  See help(type(self)) for accurate signature.\n",
      "     |  \n",
      "     |  get_variable(self)\n",
      "     |  \n",
      "     |  set_variable(self, nuevo_valor)\n",
      "     |      Asigna self.variable a un nuevo valor\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data descriptors defined here:\n",
      "     |  \n",
      "     |  __dict__\n",
      "     |      dictionary for instance variables (if defined)\n",
      "     |  \n",
      "     |  __weakref__\n",
      "     |      list of weak references to the object (if defined)\n",
      "\n",
      "FUNCTIONS\n",
      "    mi_function()\n",
      "        Función ejemplo\n",
      "\n",
      "DATA\n",
      "    mi_variable = 0\n",
      "\n",
      "FILE\n",
      "    c:\\users\\fsanmartin\\data science - juan gabriel gomila\\mimodulo.py\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(mimodulo)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 119,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mimodulo.mi_variable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mimodulo.mi_function() "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mi_clase = mimodulo.MiClase() \n",
    "mi_clase.set_variable(10)\n",
    "mi_clase.get_variable()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Excepciones\n",
    "\n",
    "En Python los errores son manejados con una construcción especial de lenguaje llamada \"Exceptions\" (excepciones). Cuando ocurre un error, una excepción puede ser hecha, que interrumpe el flujo normal del programa y retorna a algún otro lugar del código donde se definan los comandos try-except más cercanos.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para generar una excepció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": "markdown",
   "metadata": {},
   "source": [
    "Un uso típico de las excepciones es para abortar funciones cuando ocurre algú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ódigo sigue aquí"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para capturar los errores que son generados por funciones y métodos de clases, o por el mismo intérprete Python, use los comandos `try` y `except`:\n",
    "\n",
    "    try:\n",
    "        # aquí va el código normal\n",
    "    except:\n",
    "        # el código para manejar el error va aquí\n",
    "        # Este código no se ejecuta a menos que \n",
    "        # el código de arriba genere un error\n",
    "\n",
    "Por ejemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "test\n",
      "Encontré una excepción\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    print(\"test\")\n",
    "    # genera un error: ya que la variable test no está definida\n",
    "    print(test)\n",
    "except:\n",
    "    print(\"Encontré una excepción\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para obtener información sobre un error, podemos accesar la instancia de clase `Exception` que describe la excepción usando por ejemplo:\n",
    "\n",
    "    except Exception as e:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "test\n",
      "Encontré una excepción:name 'test' is not defined\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    print(\"test\")\n",
    "    # genera un error: ya que la variable test no está definida\n",
    "    print(test)\n",
    "except Exception as e:\n",
    "    print(\"Encontré una excepció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ía de estilo para la programación en Python. Altamente recomendada (en inglé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ón en Python."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Versiones"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "import IPython"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Este notebook fue evaluado con: Python 3.7.3 (default, Apr 24 2019, 15:29:51) [MSC v.1915 64 bit (AMD64)] y IPython 7.6.1.\n"
     ]
    }
   ],
   "source": [
    "print(\"Este notebook fue evaluado con: Python %s y IPython %s.\" % (sys.version, IPython.__version__))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}