Clase 1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introducción a Python para ciencias e ingenierías (notebook 1)\n",
    "\n",
    "Docente: Ing. Martín Gaitán  \n",
    "\n",
    "Twitter: `@tin_nqn_`\n",
    "\n",
    "**Links útiles**\n",
    "\n",
    "Descarga de Python \"Anaconda\": \n",
    "\n",
    "### http://continuum.io/downloads#py34  \n",
    "\n",
    "Repositorio:\n",
    "\n",
    "### http://bit.ly/cursopy\n",
    "\n",
    "Python \"temporal\" online: \n",
    "\n",
    "### http://try.jupyter.org\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ¡Empecemos! \n",
    "\n",
    "Python es un lenguaje de programación:\n",
    "\n",
    "* Interpretado e Interactivo\n",
    "* Fácil de aprender, programar y **leer** (menos *bugs*)\n",
    "* De *muy alto nivel*\n",
    "* Multiparadigma\n",
    "* Orientado a objetos\n",
    "* Libre y con licencia permisiva\n",
    "* Eficiente\n",
    "* Versátil y potente! \n",
    "* Con gran documentación\n",
    "* Y una gran comunidad de usuarios"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Instalación\n",
    "\n",
    "* En Windows o mac: recomendación [Anaconda](http://continuum.io/downloads). **Instalá la versión basada en Python 3** que corresponda a tu OS. \n",
    "\n",
    "* En linux directamente podes instalar todo lo necesario desde tus repositorios. Por ejemplo en Ubuntu: \n",
    "\n",
    "`sudo ipython ipython-notebook python-matplotlib python-numpy python-scipy python-sympy`\n",
    "\n",
    "\n",
    "---- \n",
    "\n",
    "### ¿Cómo se usa Python?\n",
    "\n",
    "#### Consolas interactivas\n",
    "\n",
    "Hay muchas maneras de usar el lenguaje Python. Dijimos que es un lenguaje **interpretado** e **interactivo**. Si ejecutamos la consola (En windows `cmd.exe`) y luego `python`, se abrirá la consola interactiva\n",
    "\n",
    "![](files/img/console.png)\n",
    "\n",
    "En la consola interactiva podemos escribir sentencias o pequeños bloques de código que son ejecutados inmediatamente. Pero *la consola interactiva* estándar es **limitada**. Mucho mejor es usar **IPython**. \n",
    "\n",
    "![](files/img/ipython.png)\n",
    "\n",
    "La consola IPython supera a la estándar en muchos sentidos. Podemos autocompletar (`<TAB>`), ver ayuda rápida de cualquier objeto (`?`) y muchas cosas más. \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Ipython Notebook (Jupyter)\n",
    "\n",
    "Y otra forma muy útil es usar los *Notebooks*. Jupyter es un entorno web para computación interactiva. \n",
    "\n",
    "\n",
    "<div class=\"alert alert-info\">Si bien nació como parte del proyecto IPython, el mismo entorno visual se puede conectar a *\"kernels\"* de distintos lenguajes. Se puede usar Jupyter con Python, Julia, R, Octave y decenas de lenguajes más.</div>\n",
    "\n",
    "\n",
    "\n",
    "Podemos crear y editar \"celdas\" de código Python que podés editar y volver a ejecutar, podés intercalar celdas de texto, fórmulas matemáticas, y hacer que gráficos se muestren inscrutados en la misma pantalla. Estos archivos se guardan con extensión *.ipynb*, que pueden exportarse a diversos formatos estátucos como html o como código python puro. (.py)\n",
    "\n",
    "Los notebooks son muy útiles para la **\"programación exploratoria\"**, muy frecuente en ciencia e ingeniería\n",
    "\n",
    "Todo el material de estos cursos estarán en formato notebook.\n",
    "\n",
    "Para ejecutar IPython Notebook, desde la consola tipear:\n",
    "\n",
    "```\n",
    "ipython notebook\n",
    "```\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Programas / scripts\n",
    "\n",
    "También podemos usar Python para hacer programas o scripts. \n",
    "Esto es, escribir nuestro código en un archivo con extensión `.py` y ejecutarlo con el intérprete de python.  \n",
    "Por ejemplo, el archivo hello.py (al que se le llama módulo) tiene este contenido:\n",
    "\n",
    "```python\n",
    "    print(\"Hello world!\")\n",
    "```\n",
    "\n",
    "Si ejecutamos python scripts/hello.py se ejecutará en el interprete Python y obtendremos el resultado"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "!python scripts/hello.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-warning\">IPython agrega muchas funcionalidades complementarias que no son parte del lenguaje Python. Por ejemplo el signo `!` que precede la línea anterior indica que se ejecutará un programa/comando del sistema en vez de código python</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "### ¿Qué editor usar?\n",
    "\n",
    "Python no exige un editor específico y hay muchos modos y maneras de programar. \n",
    "\n",
    "Un buen editor orientado a Python científico es **Spyder**, que es un entorno integrado (editor + ayuda + consola interactiva)\n",
    "\n",
    "![](files/img/spyder.png)\n",
    "\n",
    "También el entorno Jupyter trae un editor sencillo\n",
    "\n",
    "![](files/img/editor.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ¿Python 2 o Python 3? \n",
    "\n",
    "Hay dos versiones **actuales** de Python. La rama 2.7 (actualmente la version 2.7.9) y la rama 3 (actualmente 3.4)\n",
    "Todas las bibliotecas científicas de Python funcionan con ambas versiones. Pero ¡Python 3 es aún más fácil y es el que permanecerá a futuro!\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "# Listo ¡Queremos programar!\n",
    "\n",
    "\n",
    "### En el principio: Números\n",
    "\n",
    "Python es un lenguaje de muy alto nivel y por lo tanto trae muchos *tipos* de datos incluidos. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "1 + 1.4 - 12 * "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ejecuten su consola y ¡a practicar!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "2**3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "4564 % 4564"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Los tipos numéricos básicos son *int* (enteros sin limite), *float* (reales, ) y *complex* (complejos)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "(3.2 + 12j) * 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "0.1 + 0.3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "3 // 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "3 % 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Las operaciones aritméticas básicas son:\n",
    "\n",
    "* adición: `+`\n",
    "* sustracción: `-`\n",
    "* multiplicación: `*`\n",
    "* división: `/`\n",
    "* módulo (resto de división): `%`  \n",
    "* potencia: `**`\n",
    "* división entera: `//`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Las operaciones se pueden agrupar con paréntesis y tienen precedencia estándar "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "x = 1.32\n",
    "resultado = ((21.2 + 4.5)**0.2 / x) + 1j\n",
    "print(resultado)\n",
    "resultado + 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Outs vs prints\n",
    "\n",
    "* La función `print` *imprime* (muestra) el resultado por pantalla y pero **no devuelve un valor** (estrictamente devuelve `None`). Quiere decir que el valor mostrado no queda disponible para seguir operando.\n",
    "* Si la última sentencia de una celda tiene un resultado distinto a `None`, se guarda y se muestra en `Out[x]`\n",
    "* Los últimas ejecuciones se guardan en variables automáticas `_`, `__` (última y anteúltima) o en general `_x` o `Out[x]`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "_3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "1 + 2J"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "Out[6]    # que es Out (sin corchetes)?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Más funciones matemáticas\n",
    "\n",
    "Hay muchas más *funciones* matemáticas y algunas constantes extras definidas en el *módulo* `math`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import math   # se importa el modulo para poder usar sus funciones"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "math.sin(1*math.pi)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# round es una función built-in\n",
    "round(5.6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "round(math.pi, 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "math.ceil(5.4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "math.trunc(5.8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "math.factorial(1e4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "math.sqrt(-1)  # Epa!!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pero existe un módulo equivalente para operaciones sobre el dominio complejo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import cmath\n",
    "cmath.sqrt(-1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Todo es un \"objeto\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En Python todo es un *objeto*, es decir, una *instancia* de un clase o tipo de datos. Los objetos no solo *guardan* valores (atributos) sino que que tienen acceso a *métodos*, es decir, traen acciones (funciones) que podemos ejecutar sobre esos valores, a veces requiriendo/permitiendo parámetros adicionales. \n",
    "\n",
    "Jupyter/IPython facilita conocer todos los atributos y métodos de un objeto mediante **instrospección**. Prueben escribir `resutado.` y apretar `<TAB>`. Por ejemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "resultado.conjugate()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Además del `TAB`, en una sesión interactiva de Jupyter, se puede obtener ayuda contextual para cualquier objeto (cualquier cosa!) haciendo `Shift + TAB` una o más veces, o agregando un signo de interrogación al final (`blah?`) y ejecutando"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En python \"puro\", estos comportamientos se logran con las funciones `dir()` y `help()`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para conocer la clase/tipo de cualquier objecto se usa `type`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En muchos casos, se puede convertir explícitamente (o \"castear\") tipos de datos. En particular, entre números:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Ejercicios\n",
    "\n",
    "1. Crear una variable llamada `magnitud` con un valor real. Definir otra variable compleja `intensidad` cuya parte real sea 1.5 veces `magnitud` y la parte imaginaria `0.3` veces `magnitud` + `1j`. Encontrar la raiz cuadrada de `intensidad`. \n",
    "\n",
    "2. Para calcular un [interés compuesto](https://es.wikipedia.org/wiki/Inter%C3%A9s_compuesto) se utiliza la fórmula\n",
    "\n",
    "$$ \\ C_F = C_I(1+r)^n $$\n",
    "\n",
    "Donde:\n",
    "\n",
    "* $ \\ C_F $ es el capital al final del enésimo período\n",
    "* $ \\ C_I $ es el capital inicial\n",
    "* $ \\ r $ es la tasa de interés expresada en tanto por uno (v.g., 4&nbsp;% = 0,04) \n",
    "* $ \\ n $ es el número de períodos\n",
    "\n",
    "Codifique la fórmula en una celda y calcule el capital final para un depósito inicial de 10 mil pesos a una tasa del 1.2% mensual en 18 meses.\n",
    "\n",
    "\n",
    "3. Investigue, a través de la ayuda interactiva, el parámetro opcional de `int` y las funciones `bin`, `oct` y `hex`. Basado en esto exprese en base 2 la operación  1 << 2 y  en base hexadecimal `FA1` * `O17` "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "magnitud = .4\n",
    "intensidad = 1.5 * magnitud + 1j*(0.3*magnitud + 1)\n",
    "cmath.sqrt(intensidad)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "int('10', 8)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Texto\n",
    "\n",
    "Una cadena o *string* es una **secuencia** de caracteres (letras, números, simbolos). Python 3 utiliza el estándar [unicode](http://es.wikipedia.org/wiki/Unicode). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "print(\"Hola mundo!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "chinito = \"字漢字\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "type(chinito)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "De paso, `unicode` se aplica a todo el lenguaje, de manera que el propio código puede usar caracterés \"no ascii\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "años = 18"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Las cadenas se pueden definir con apóstrofes, comillas, o triple comillas, de manera que es menos frecuente la necesidad de \"escapar\" caracteres"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "calle = \"O'Higgings\"\n",
    "metáfora = 'Los \"patitos\" en fila'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Las triples comillas permiten crear cadenas multilínea"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "\"\"\"Me gustas cuando \"callas\"\n",
    "porque estás como ausente...\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "poema = _"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "print(poema)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "poema."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Las cadenas tienen sus propios **métodos**: pasar a mayúsculas, capitalizar, reemplazar una subcadena, etc. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "print(poema.replace('gustas', 'molestas').replace('callas', 'hablas').replace('como ausente', 'demasiado gritona'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "calle.lower()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Las cadenas se pueden concatenar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "calle + \" fue un soldado de San Martín\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "y repetir"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "\"*\" * 80    # repetición"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "int('2') / 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para separar una cadena se usa el método `split`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "\"hola boca de mi vida\".split('boca')   # devuelve una lista de cadenas (ya vemos más)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Y el método inverso es `join`, para unir muchas cadenas intercalandolas con otra"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "\"-\".join(['y', 'jugando', 'al', 'amor', 'nos', 'encontró'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Indizado y rebanado"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Las cadenas son **secuencias**. O sea, conjuntos ordenados que se pueden indizar, recortar, reordenar, etc. \n",
    "\n",
    "![](/files/img/index_slicing.png)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "cadena = \"HOLA MUNDO\"\n",
    "\n",
    "cadena[-2]     "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "cadena[::-1]   #wow!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "cadena[3:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El tipo `str` en python es **inmutable**, lo que quiere decir que, una vez definido un objeto tipo cadena no podemos modificarlo. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "cadena[0] = 'B'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "'B' + cadena[1:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "cadena = cadena.replace('H', 'B')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pero si podemos basarnos en un string para crear otro"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "cadena[:4] + \" SUB\" + cadena[5:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### longitud de una secuencia\n",
    "\n",
    "La función `len` (de *lenght*) devuelve la cantidad de elementos de cualquier secuencia"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "len(cadena)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### interpolación\n",
    "\n",
    "Se puede crear un string a partir de una \"plantilla\" con un formato predeterminado. La forma más poderosa es a través del método [`format`](https://docs.python.org/3.4/library/string.html#format-examples)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "\"%s mundo\" % \"hola\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "\"{saludo} {planeta}\".format(saludo='Hola', planeta='Mundo')    # placeholders por nombre de argumentos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "\"La parte real es {0.real:.5f} y la imaginaria es {0.imag}\".format(resultado)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Casting de tipos\n",
    "\n",
    "Python es dinámico pero de **tipado es fuerte**. Quiere decir que no intenta adivinar lo que estamos intentando hacer y nos exige ser explícitos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "\"2\" + \"2\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "int(\"2\") + int(\"2\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "\n",
    "float('2.34545') ** 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Ejercicios\n",
    "\n",
    "\n",
    "1. Dado un texto cualquiera, crear uno equivalente con \"subrayado\" con el caracter \"=\" en toda su longitud . Por ejemplo, `\"Beso a Beso\"`, se debe imprimir por pantalla\n",
    "\n",
    "        Beso a Beso\n",
    "        ===========\n",
    "\n",
    "2. Dada una cadena de palabras separadas por coma, generar otra cadena multilinea de \"items\" que comienzan por `\"* \"`. Por ejemplo \"manzanas, naranjas, bananas\" debe imprimir:\n",
    "\n",
    "        * manzanas\n",
    "        * naranjas\n",
    "        * bananas\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "%%timeit\n",
    "cadena = \"Beso a Beso me enamoré\"\n",
    "longitud = len(cadena)\n",
    "subrayado = \"=\" * longitud\n",
    "print\"\"\"{}\n",
    "{}\n",
    "\"\"\".format(cadena, subrayado))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%timeit?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "cadena = \"Beso a Beso me enamoré\"\n",
    "longitud = len(cadena)\n",
    "subrayado = \"=\" * longitud\n",
    "\n",
    "print(cadena + '\\n' + subrayado)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "\"b, a, c\".split(', ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "----\n",
    "\n",
    "### Listas y tuplas: contenedores universales"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "nombres = [\"Melisa\", \"Nadia\", \"Daniel\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "type(nombres)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Las listas tambien son secuencias, por lo que el indizado y rebanado funciona igual"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "nombres[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "nombres[-2:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Y pueden contener cualquier tipo de objetos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "mezcolanza = [1.2, \"Jairo\", 12e6, calle, nombres[1]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "print(mezcolanza)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hasta acá son iguales a las **tuplas**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "una_tupla = (\"Martín\", 1.2, (1j, nombres[0]))\n",
    "print(type(una_tupla))\n",
    "print(una_tupla[1:3])\n",
    "una_tupla"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**LA DIFERENCIA** es que las **listas son mutables**. Es decir, es un objeto que puede cambiar: extenderse con otra secuencia, agregar o quitar elementos, cambiar un elemento o una porción por otra, reordenarse *in place*, etc.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "mezcolanza.append(\"otro elemento\")\n",
    "mezcolanza"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "una_tupla.append('a')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "mezcolanza[-1] = \"otra cosa\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "mezcolanza"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Incluso se pueden hacer asignaciones de secuencias sobres \"slices\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "mezcolanza[0:2] = ['A', 'B']     # notar que no hace falta que el valor tenga el mismo tamaño que el slice\n",
    "mezcolanza"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como las tuplas son inmutables (como las cadenas), no podemos hacer asignaciones"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "una_tupla[-1] = \"osooo\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Las **tuplas** son mucho más eficientes (y seguras) si sólo vamos a **leer** elementos. Pero muchas operaciones son comunes. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "l = [1, 3, 4, 1]\n",
    "t = (1, 3, 1, 4)\n",
    "print(l.count(3))\n",
    "print(t.count(3))\n",
    "l.append('8')\n",
    "l"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### packing/unpacking\n",
    "\n",
    "Como toda secuencia, las listas y tuplas se pueden *desempacar*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "nombre, nota = (\"Juan\", 10)\n",
    "print(\"{} se sacó un {}\".format(nombre, nota))     # igual a \"{0} se sacó un {1}\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "a, b = 1, 2.0\n",
    "a, b = b, a\n",
    "print (a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python 3 permite un desempacado extendido"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "a, b, *c = (1, 2, 3, 4, 5)\n",
    "print((a, b, c))\n",
    "\n",
    "a, *b, c = [1, 2, 3, 4, 5]\n",
    "print((a, b, c))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "v = [1, 2, 3, 4, 5]\n",
    "a, b, c = (v[0], v[1:-1], v[-1])\n",
    "print(a, b, c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como con los números, se pueden convertir las secuencias de un tipo de dato a otro. Por ejemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "a = (1, 3, 4)\n",
    "list(('A', 1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Una función *builtin* muy útil es `range`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "list(range(10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "range(6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "range(-10, 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "range(0, 25, 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "También hay una función estándar que da la sumatoria"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "help(sum)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "sum([1, 5.36, 5, 10])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En toda secuencia tenemos el método index, que devuelve la posición en la que se encuentra un elemento"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "a = [1, 'hola', []]\n",
    "a.index('hola')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "y como las listas son *mutables* también se pueden reordenar *in place* (no se devuelve un valor, se cambia sobre la misma variable)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "a.reverse()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "list(reversed(t))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La forma alternativa es usando una función, que **devuelve** un valor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "b = list(reversed(a))\n",
    "b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-warning\">*Nota*: se fuerza la conversión de tipo con `list()` porque reversed no devuelve estrictamente una lista. Ya veremos más sobre esto.</div>\n",
    "\n",
    "Una función útil es `zip()`, que agrupa elementos de distintas secuencias"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "nombres = ['Juan', 'Martín', 'María']\n",
    "pasiones = ['cerveza', 'boca juniors', 'lechuga', 1]\n",
    "nacionalidad = ('arg', 'chi', 'ita')\n",
    "list(zip(nombres, pasiones))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Ejercicios\n",
    "\n",
    "1. Resuelva la siguiente operación $$\\frac{(\\sum_{k=0}^{100}k)^3}{2}$$\n",
    "\n",
    "2. Dada cualquier secuencia, devolver una tupla con sus elementos concatenados en a la misma secuencia en orden inverso. Por ejemplo para `\"ABCD\"` devuelve `('A', 'B', 'C', 'D', 'D', 'C', 'B', 'A')`\n",
    "\n",
    "3. Generar dos listas a partir de la funcion `range` de 10 elementos, la primera con los primeros multiplos de 2 a partir de 0 y la segunda los primeros multiplos de 3 a partir de 30 (inclusive). Devolver como una lista de tuplas\n",
    "`[(0, 30), (2, 33),... ]`\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "sum(range(0, 101))**3/2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "t = list(\"ABCD\")\n",
    "tuple(t + list(reversed(t)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Estructuras de control de flujos\n",
    "\n",
    "#### if/elif/else\n",
    "\n",
    "En todo lenguaje necesitamos controlar el flujo de una ejecución segun una condición Verdadero/Falso (booleana). *Si (condicion) es verdadero hacé (bloque A); Sino hacé (Bloque B)*. En pseudo código:\n",
    "\n",
    "    Si (condicion):\n",
    "        bloque A\n",
    "    sino:\n",
    "        bloque B\n",
    "\n",
    "y en Python es muy parecido! \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "edad: 20\n",
      "Bienvenido, jovatón\n"
     ]
    }
   ],
   "source": [
    "edad = int(input('edad: '))\n",
    "if edad < 18:\n",
    "    print(\"Usted es menor de edad. Raje de acá, pendejo\")    \n",
    "else:\n",
    "    print(\"Bienvenido, jovatón\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bool()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Los operadores lógicos en Python son muy explicitos. \n",
    "    \n",
    "    A == B \n",
    "    A > B \n",
    "    A < B\n",
    "    A >= B\n",
    "    A <= B\n",
    "    A != B\n",
    "    A in B\n",
    "\n",
    "* A todos los podemos combinar con `not`, que niega la condición\n",
    "* Podemos combinar condiciones con `AND` y `OR`, las funciones `all` y `any` y paréntesis"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos tener multiples condiciones en una estructura. Se ejecutará el primer bloque cuya condición sea verdadera, o en su defecto el bloque `else`. Esto es equivalente a la sentencia `switch` o `select case` de otros lenguajes "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "if edad < 12:\n",
    "    print(\"Feliz dia del niño\")\n",
    "elif 13 < edad < 18:\n",
    "    print(\"Qué problema los granitos, no?\")\n",
    "elif edad in range(19, 90):\n",
    "    print(\"No seré feliz pero tengo marido\")\n",
    "else:\n",
    "    print(\"Y eso es todo amigos!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "type(edad < 12)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En un `if`, la conversión a tipo *boolean* es implícita. El tipo `None` (vacío), el `0`,  una secuencia (lista, tupla, string) (o conjunto o diccionario, que ya veremos) vacía siempre evalua a ``False``. Cualquier otro objeto evalua a ``True``."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "if 5 - 5: \n",
    "    a = \"No es cero\"\n",
    "else: \n",
    "    a = \"Dio cero\"\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para hacer asignaciones condicionales se puede usar la *estructura ternaria* del `if`: `A si (condicion) sino B`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "a = \"No es cero\" if (5-5) else \"dio cero\"\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Ejercicio\n",
    "\n",
    "dados **valores** numéricos para a, b y c, implementar la formula  d $x = \\frac{-b \\pm \\sqrt {b^2-4ac}}{2a}$\n",
    "\n",
    "donde a, b y c son lo coeficientes de la ecuación $ax^2 + bx + c  = 0, \\quad \\mbox{para}\\;a\\neq 0$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### For\n",
    "\n",
    "Otro control es **iterar** sobre una secuencia (o *\"iterador\"*). Obtener cada elemento para hacer algo. En Python se logra con la sentencia `for`\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "sumatoria = 0\n",
    "for elemento in [1, 2, 3.6]:\n",
    "    sumatoria = sumatoria + elemento\n",
    "sumatoria"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(0, 'a'), (1, 'b'), (2, 'c')]"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(enumerate(['a', 'b', 'c']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notar que no iteramos sobre el índice de cada elemento, sino sobre los elementos mismos. ¡Basta de `i`, `j` y esas variables innecesarias! . Si por alguna razon son necesarias, tenemos la función `enumerate`\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "El valor de la posicion 0 es 4\n",
      "El valor de la posicion 1 es 3\n",
      "El valor de la posicion 2 es 19\n"
     ]
    }
   ],
   "source": [
    "for (posicion, valor) in enumerate([4, 3, 19]):\n",
    "    print(\"El valor de la posicion %s es %d\" % (posicion, valor))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El bloque `for` se corre hasta el final del *iterador* o hasta encontrar un sentencia `break`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(5050, 101)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sumatoria = 0\n",
    "for elemento in range(1000):\n",
    "    if elemento > 100:\n",
    "        break\n",
    "    sumatoria = sumatoria + elemento\n",
    "sumatoria, elemento"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "También podemos usar `continue` para omitir la ejecución de \"una iteración\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "2\n",
      "4\n",
      "6\n",
      "8\n",
      "10\n",
      "12\n",
      "14\n",
      "16\n",
      "18\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "90"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sumatoria = 0\n",
    "for elemento in range(20):\n",
    "    if elemento % 2:\n",
    "        continue\n",
    "    print(elemento)\n",
    "    sumatoria = sumatoria + elemento\n",
    "sumatoria"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Muchas veces queremos iterar una lista para obtener otra, con sus elementos modificados. Por ejemplo, obtener una lista con los cuadrados de los primeros 10 enteros."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[9, 4, 1, 0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121, 144, 169, 196]\n"
     ]
    }
   ],
   "source": [
    "cuadrados = []\n",
    "for i in range(-3,15,1):\n",
    "    cuadrados.append(i**2)\n",
    "print (cuadrados)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Una forma compacta y elegante (¡pythónica!) de escribir esta estructura muy frecuente son las **listas por comprehensión**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[9, 4, 1, 0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121, 144, 169, 196]"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "guardado = [i**2 for i in range(-3,15,1) if i % 2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0,\n",
       " 2,\n",
       " 4,\n",
       " 6,\n",
       " 8,\n",
       " 10,\n",
       " 12,\n",
       " 14,\n",
       " 16,\n",
       " 18,\n",
       " 20,\n",
       " 22,\n",
       " 24,\n",
       " 26,\n",
       " 28,\n",
       " 30,\n",
       " 32,\n",
       " 34,\n",
       " 36,\n",
       " 38,\n",
       " 40,\n",
       " 42,\n",
       " 44,\n",
       " 46,\n",
       " 48,\n",
       " 50,\n",
       " 52,\n",
       " 54,\n",
       " 56,\n",
       " 58,\n",
       " 60,\n",
       " 62,\n",
       " 64,\n",
       " 66,\n",
       " 68,\n",
       " 70,\n",
       " 72,\n",
       " 74,\n",
       " 76,\n",
       " 78,\n",
       " 80,\n",
       " 82,\n",
       " 84,\n",
       " 86,\n",
       " 88,\n",
       " 90,\n",
       " 92,\n",
       " 94,\n",
       " 96,\n",
       " 98,\n",
       " 100,\n",
       " 102,\n",
       " 104,\n",
       " 106,\n",
       " 108,\n",
       " 110,\n",
       " 112,\n",
       " 114,\n",
       " 116,\n",
       " 118,\n",
       " 120,\n",
       " 122,\n",
       " 124,\n",
       " 126,\n",
       " 128,\n",
       " 130,\n",
       " 132,\n",
       " 134,\n",
       " 136,\n",
       " 138,\n",
       " 140,\n",
       " 142,\n",
       " 144,\n",
       " 146,\n",
       " 148,\n",
       " 150,\n",
       " 152,\n",
       " 154,\n",
       " 156,\n",
       " 158,\n",
       " 160,\n",
       " 162,\n",
       " 164,\n",
       " 166,\n",
       " 168,\n",
       " 170,\n",
       " 172,\n",
       " 174,\n",
       " 176,\n",
       " 178,\n",
       " 180,\n",
       " 182,\n",
       " 184,\n",
       " 186,\n",
       " 188,\n",
       " 190,\n",
       " 192,\n",
       " 194,\n",
       " 196,\n",
       " 198]"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[n*2 for n in range(100)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se lee: \"Obtener el cuadrado de cada elemento i de la secuencia (rango 0 a 9)\". Pero además podemos filtrar: usar solo los elementos que cumplen una condición. \n",
    "\n",
    "#### Ejercicios\n",
    "\n",
    "1. Obtener la sumatoria de los cubos de los numeros impares menores a 100. $$\\sum_{a=0}^{100}a^3 \\mid a\\ impar $$\n",
    "\n",
    "2. Obtener la productoria de los primeros 12 digitos decimales de PI\n",
    "3. Encuentre el mínimo de $$f(x) = (x-4)^2-3 \\mid x \\in  [-100, 100)$$ \n",
    "4. Encuentre el promedio de los números reales de la cadena `\"3,4   1,2  -6   0  9,7\"`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12497500"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum([a**3 for a in range(101) if a % 2 == 1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "58"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import math\n",
    "sum([int(digito) for digito in str(math.pi)[2:14]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Expresiones generadores\n",
    "\n",
    "Al crear una lista por comprehensión, se calculan todos los valores y se agregan uno a uno a la lista, que una vez completa se \"devuelve\" como un objeto nuevo. \n",
    "\n",
    "Cuando no necesitamos todos los valores *al mismo tiempo*, porque por ejemplo podemos consumirlos de 1 en 1, es mejor crear *generadores*, que son tipos de datos **iterables pero no indizables** (es el mismo tipo de objeto que devuelve `reversed`, que ya vimos)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "285"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(a**2 for a in range(10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### While\n",
    "\n",
    "Otro tipo de sentencia de control es *while*: iterar mientras se cumpla una condición"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "a = 0\n",
    "while a < 10:\n",
    "    print (a)\n",
    "    a += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como en la iteración con `for` se puede utilizar la sentencia `break` para \"romper\" el bucle. Entonces puede modificarse para que la condición esté en una posicion arbitraria"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 elefantes se balanceaban sobre la tela de una araña\n",
      "Desea invitar a otro elefante?\n",
      "3 elefantes se balanceaban sobre la tela de una araña\n",
      "Desea invitar a otro elefante?2\n",
      "4 elefantes se balanceaban sobre la tela de una araña\n",
      "Desea invitar a otro elefante?3\n",
      "5 elefantes se balanceaban sobre la tela de una araña\n",
      "Desea invitar a otro elefante?no\n"
     ]
    }
   ],
   "source": [
    "n = 1\n",
    "while True:\n",
    "    n = n + 1\n",
    "    print('{} elefantes se balanceaban sobre la tela de una araña'.format(n))\n",
    "    continuar = input('Desea invitar a otro elefante?')\n",
    "    if continuar == 'no':\n",
    "        break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "min"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Diccionarios\n",
    "\n",
    "La diccionarios son otro tipo de estructuras de alto nivel que ya vienen incorporados. A diferencia de las secuencias, los valores **no están en una posición** sino bajo **una clave**: son asociaciones `clave:valor`\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "camisetas = {'Orión': 1, 'Carlitos': 10, 'Gago': 5, 'Gaitán': 'Jugador nº 12'} "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Accedemos al valor a traves de un clave"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "camisetas['Perez'] = 8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Carlitos': 10, 'Gago': 5, 'Gaitán': 'Jugador nº 12', 'Orión': 1, 'Perez': 8}"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "camisetas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Las claves pueden ser cualquier objeto inmutable (cadenas, numeros, tuplas) y los valores pueden ser cualquier tipo de objeto. Las claves no se pueden repetir pero los valores sí.\n",
    "\n",
    "**Importante**: los diccionarios **no tienen un orden definido**. Si por alguna razón necesitamos un orden, debemos obtener las claves, ordenarlas e iterar por esa secuencia de claves ordenadas.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Perez', 'Orión', 'Gaitán', 'Gago', 'Carlitos']"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorted(camisetas.keys(), reverse=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Los diccionarios **son mutables**. Es decir, podemos cambiar el valor de una clave, agregar o quitar.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('Gaitán', 'Jugador nº 12'),\n",
       " ('Perez', 8),\n",
       " ('Orión', 1),\n",
       " ('Carlitos', 10),\n",
       " ('Gago', 5)]"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(camisetas.items())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hay muchos *métodos* útiles"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Perez lleva la 8\n",
      "Orión lleva la 1\n",
      "Carlitos lleva la 10\n",
      "Gago lleva la 5\n"
     ]
    }
   ],
   "source": [
    "for jugador, camiseta in camisetas.items():\n",
    "    if jugador == 'Gaitán':\n",
    "        continue    \n",
    "    print(\"%s lleva la %d\" % (jugador, camiseta))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se puede crear un diccionario a partir de tuplas `(clave, valor)` a traves de la propia clase `dict()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Cismondi': 'cismondi@phasety.com',\n",
       " 'Melisa': 'mgomez@phasety.com',\n",
       " 'Yo': 'gaitan@gmail.com'}"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dict([('Yo', 'gaitan@gmail.com'), ('Melisa', 'mgomez@phasety.com'), ('Cismondi', 'cismondi@phasety.com')])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Que es muy útil usar con la función `zip()` que ya vimos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Mariano': 'nano@email.com', 'Martin': 'tin@email.com'}"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nombres = (\"Martin\", \"Mariano\")\n",
    "emails = (\"tin@email.com\", \"nano@email.com\")\n",
    "\n",
    "dict(zip(nombres, emails))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Ejercicio\n",
    "\n",
    "#. Dados la lista de precios por kilo:\n",
    "\n",
    "        precios = {\n",
    "            \"banana\": 12,\n",
    "            \"manzana\": 8.5,\n",
    "            \"naranja\": 6,\n",
    "            \"pera\": 18\n",
    "        }\n",
    "\n",
    " Y la siguiente lista de compras \n",
    "\n",
    "        compras = {\n",
    "            \"banana\": 1,\n",
    "            \"naranja\": 3,\n",
    "            \"pera\": 0,\n",
    "            \"manzana\": 1\n",
    "        }\n",
    "\n",
    " Calcule el costo total de la compra. \n",
    "\n",
    "\n",
    "#. Ejecute `import this` y luego analice el código del módulo con `this??`  . ¿comprende el algoritmo? Cree el algoritmo inverso, es decir, codificador de [rot13](https://es.wikipedia.org/wiki/ROT13)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The Zen of Python, by Tim Peters\n",
      "\n",
      "Beautiful is better than ugly.\n",
      "Explicit is better than implicit.\n",
      "Simple is better than complex.\n",
      "Complex is better than complicated.\n",
      "Flat is better than nested.\n",
      "Sparse is better than dense.\n",
      "Readability counts.\n",
      "Special cases aren't special enough to break the rules.\n",
      "Although practicality beats purity.\n",
      "Errors should never pass silently.\n",
      "Unless explicitly silenced.\n",
      "In the face of ambiguity, refuse the temptation to guess.\n",
      "There should be one-- and preferably only one --obvious way to do it.\n",
      "Although that way may not be obvious at first unless you're Dutch.\n",
      "Now is better than never.\n",
      "Although never is often better than *right* now.\n",
      "If the implementation is hard to explain, it's a bad idea.\n",
      "If the implementation is easy to explain, it may be a good idea.\n",
      "Namespaces are one honking great idea -- let's do more of those!\n"
     ]
    }
   ],
   "source": [
    "import this"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "this??"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Conjuntos\n",
    "\n",
    "Los conjuntos (`set()` o `{}`) son grupos de elementos únicos. Al igual que los diccionarios, no están necesariamente ordenados"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "mamiferos = set(['perro', 'gato', 'leon'])\n",
    "domesticos = {'perro', 'gato', 'gallina'}\n",
    "aves = {'gallina', 'halcón', 'colibrí'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "mamiferos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Los conjuntos tienen métodos para cada una de las operaciones del [álgebra de conjuntos](https://es.wikipedia.org/wiki/%C3%81lgebra_de_conjuntos)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'gato', 'perro'}"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mamiferos.intersection(domesticos)    #  mamiferos & domesticos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'gallina', 'gato', 'leon', 'perro'}"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mamiferos.union(domesticos)     #  mamiferos | domesticos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'colibrí', 'halcón'}"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "aves.difference(domesticos)     # mamiferos - domesticos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'gallina', 'leon'}"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mamiferos.symmetric_difference(domesticos)    # mamiferos ^ domesticos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se puede comparar pertenencia de elementos y subconjuntos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'gato' in mamiferos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "domesticos.issubset(mamiferos)  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Además, tienen métodos para agregar o extraer elementos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'elefante', 'gato', 'leon', 'perro'}"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mamiferos.add('elefante')\n",
    "mamiferos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Por supuesto, se puede crear un conjunto a partir de cualquier iterador"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3}"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set([1, 2, 3, 2, 1, 3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "frozenset"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "Existe también una **versión inmutable** de los diccionarios, llamado `frozenset`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Ejercicio\n",
    "\n",
    "La función `dir()` devuelve una lista con los nombre de todos los métodos y atributos de un objeto. Obtener una lista ordenada de los métodos en común entre `list`, `tuple` y `str` y los que son exclusivos para cada uno"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'__add__',\n",
       " '__class__',\n",
       " '__contains__',\n",
       " '__delattr__',\n",
       " '__dir__',\n",
       " '__doc__',\n",
       " '__eq__',\n",
       " '__format__',\n",
       " '__ge__',\n",
       " '__getattribute__',\n",
       " '__getitem__',\n",
       " '__gt__',\n",
       " '__hash__',\n",
       " '__init__',\n",
       " '__iter__',\n",
       " '__le__',\n",
       " '__len__',\n",
       " '__lt__',\n",
       " '__mul__',\n",
       " '__ne__',\n",
       " '__new__',\n",
       " '__reduce__',\n",
       " '__reduce_ex__',\n",
       " '__repr__',\n",
       " '__rmul__',\n",
       " '__setattr__',\n",
       " '__sizeof__',\n",
       " '__str__',\n",
       " '__subclasshook__',\n",
       " 'count',\n",
       " 'index'}"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = [1]\n",
    "\n",
    "set(dir(list)) & set(dir(tuple)) & set(dir(str))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.4.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}