diff --git a/Clase 1.ipynb b/Clase 1.ipynb
index 0ffd0ce..1bb6fb8 100644
--- a/Clase 1.ipynb	
+++ b/Clase 1.ipynb	
@@ -12,19 +12,17 @@
     "\n",
     "**Links útiles**\n",
     "\n",
-    "Descarga de Python \"Anaconda\": http://continuum.io/downloads  \n",
+    "Descarga de Python \"Anaconda\": \n",
     "\n",
-    "Repositorio:\n",
-    "\n",
-    "## http://bit.ly/cursopy\n",
+    "### http://continuum.io/downloads#py34  \n",
     "\n",
-    "Descarga de notebooks:\n",
+    "Repositorio:\n",
     "\n",
-    "## http://bit.ly/cursopy_zip\n",
+    "### http://bit.ly/cursopy\n",
     "\n",
     "Python \"temporal\" online: \n",
     "\n",
-    "## http://try.jupyter.org\n"
+    "### http://try.jupyter.org\n"
    ]
   },
   {
@@ -53,7 +51,7 @@
    "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",
+    "* 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",
@@ -122,19 +120,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "metadata": {
     "collapsed": false
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Hello world!\r\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "!python scripts/hello.py"
    ]
@@ -189,22 +179,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": null,
    "metadata": {
     "collapsed": false
    },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "-21.6"
-      ]
-     },
-     "execution_count": 2,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "1 + 1.4 - 12 * 2"
    ]
@@ -218,44 +197,22 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": null,
    "metadata": {
     "collapsed": false
    },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "8"
-      ]
-     },
-     "execution_count": 2,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "2**3"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": null,
    "metadata": {
     "collapsed": false
    },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "0"
-      ]
-     },
-     "execution_count": 3,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "4564 % 4564"
    ]
@@ -264,12 +221,23 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Los tipos numéricos básicos son *integer* (enteros sin limite), *float* (reales) y *complex* (complejos)"
+    "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": 4,
+   "execution_count": 3,
    "metadata": {
     "collapsed": false
    },
@@ -277,54 +245,97 @@
     {
      "data": {
       "text/plain": [
-       "(6.4+24j)"
+       "0.4"
       ]
      },
-     "execution_count": 4,
+     "execution_count": 3,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "(3.2 + 12j) * 2"
+    "0.1 + 0.3"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": null,
    "metadata": {
-    "collapsed": true
+    "collapsed": false
    },
    "outputs": [],
    "source": [
-    "import math"
+    "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": 6,
+   "execution_count": 20,
    "metadata": {
     "collapsed": false
    },
    "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(1.4501492204343935+1j)\n"
+     ]
+    },
     {
      "data": {
       "text/plain": [
-       "1.4142135623730951"
+       "(1.4501492204343935+1j)"
       ]
      },
-     "execution_count": 6,
+     "execution_count": 20,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "math.sqrt(2)"
+    "x = 1.32\n",
+    "resultado = ((21.2 + 4.5)**0.2 / x) + 1j\n",
+    "print(resultado)\n",
+    "resultado"
+   ]
+  },
+  {
+   "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": 9,
+   "execution_count": 21,
    "metadata": {
     "collapsed": false
    },
@@ -332,22 +343,21 @@
     {
      "data": {
       "text/plain": [
-       "1j"
+       "0.4"
       ]
      },
-     "execution_count": 9,
+     "execution_count": 21,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "import cmath\n",
-    "cmath.sqrt(-1)"
+    "_3"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 25,
    "metadata": {
     "collapsed": false
    },
@@ -355,70 +365,75 @@
     {
      "data": {
       "text/plain": [
-       "1.5"
+       "0.4"
       ]
      },
-     "execution_count": 10,
+     "execution_count": 25,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "3 / 2"
+    "Out[3]    # que es Out (sin corchetes)?"
    ]
   },
   {
    "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: `%`\n",
-    "* potencia: `**`\n",
-    "* división entera: `//`\n",
+    "#### Más funciones matemáticas\n",
     "\n",
-    "Las operaciones se pueden agrupar con parentesis y tienen precedencia estándar "
+    "Hay muchas más *funciones* matemáticas y algunas constantes extras definidas en el *módulo* `math`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "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.sqrt(2)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 31,
+   "execution_count": 1,
    "metadata": {
     "collapsed": false
    },
    "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "(1.5951641424778331+1j)\n"
-     ]
-    },
     {
      "data": {
       "text/plain": [
-       "(1.5951641424778331+1j)"
+       "6"
       ]
      },
-     "execution_count": 31,
+     "execution_count": 1,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "x=1.32\n",
-    "resultado = ((21.2 + 4.5)**0.2 / 1.2) + 1j\n",
-    "print(resultado)\n",
-    "resultado"
+    "# round es una función built-in\n",
+    "round(5.6)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": 8,
    "metadata": {
     "collapsed": false
    },
@@ -426,54 +441,107 @@
     {
      "data": {
       "text/plain": [
-       "1.5951641424778331"
+       "3.1416"
       ]
      },
-     "execution_count": 18,
+     "execution_count": 8,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "resultado.real"
+    "round(math.pi, 4)"
    ]
   },
   {
-   "cell_type": "markdown",
-   "metadata": {},
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [],
    "source": [
-    "**Atenti**: El modo interactivo `print` *imprime* el resultado pero no *devuelve* un output. `int()` es el tipo de datos para enteros y permite forzar que el resultado sea de este tipo (truncado). \n",
-    "\n",
-    "El resultado quedó guardado en la *variable* `resultado`. \n"
+    "math.ceil(5.4)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "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": 19,
+   "execution_count": 11,
    "metadata": {
     "collapsed": false
    },
    "outputs": [
     {
-     "data": {
-      "text/plain": [
-       "complex"
-      ]
-     },
-     "execution_count": 19,
-     "metadata": {},
-     "output_type": "execute_result"
+     "ename": "ValueError",
+     "evalue": "math domain error",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
+      "\u001b[1;32m<ipython-input-11-a8152a31b172>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mmath\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0msqrt\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m-\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m)\u001b[0m  \u001b[1;31m# Epa!!\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
+      "\u001b[1;31mValueError\u001b[0m: math domain error"
+     ]
     }
    ],
    "source": [
-    "type(resultado)"
+    "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*. Los objetos no solo *guardan* valores sino que que tienen *métodos*. Es decir, traen \"funciones\" (acciones) que podemos ejecutarles. Prueben escribir `resutado.` y apretar `<TAB>`. Por ejemplo:"
+    "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:"
    ]
   },
   {
@@ -484,25 +552,46 @@
    },
    "outputs": [],
    "source": [
-    "resultado.conjugate()"
+    "resultado.c"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "En una sesión interactiva el `?` brinda ayuda contextual"
+    "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": 20,
+   "execution_count": null,
    "metadata": {
     "collapsed": false
    },
    "outputs": [],
    "source": [
-    "resultado.conjugate"
+    "resultado?"
+   ]
+  },
+  {
+   "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:"
    ]
   },
   {
@@ -511,55 +600,59 @@
    "source": [
     "##### Ejercicios\n",
     "\n",
-    "1. Crear una variable llamada `magnitud` con un valor real\n",
-    "2. Definir otra variable compleja `intensidad` cuya parte real sea 1.5 veces `magnitud` y la parte imaginaria 0.3 veces `magnitud` + 1j\n",
-    "3. Encontrar la raiz cuadrada de `intensidad`\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": "markdown",
    "metadata": {},
    "source": [
-    "### Unicode: Secuencias de caracteres\n",
+    "### 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).\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": 21,
+   "execution_count": null,
    "metadata": {
     "collapsed": false
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Hola mundo!\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "print(\"Hola mundo!\")"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 22,
+   "execution_count": 34,
    "metadata": {
     "collapsed": false
    },
    "outputs": [],
    "source": [
-    "chinito = '字漢字´ñññ'"
+    "chinito = '字漢字'"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 23,
+   "execution_count": 35,
    "metadata": {
     "collapsed": false
    },
@@ -570,7 +663,7 @@
        "str"
       ]
      },
-     "execution_count": 23,
+     "execution_count": 35,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -579,9 +672,16 @@
     "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": 24,
+   "execution_count": null,
    "metadata": {
     "collapsed": true
    },
@@ -594,47 +694,54 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Se pueden definir con apóstrofes, comillas, o triple comillas"
+    "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": 26,
+   "execution_count": 39,
    "metadata": {
     "collapsed": false
    },
    "outputs": [],
    "source": [
-    "calle = \"\"\"O'Higgings\n",
-    "\n",
-    "\n",
-    "dfdsfds\"\"\""
+    "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": 32,
+   "execution_count": 36,
    "metadata": {
     "collapsed": false
    },
    "outputs": [
     {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Me gustas cuando \"callas\"\n",
-      "porque estás como ausente...\n"
-     ]
+     "data": {
+      "text/plain": [
+       "'Me gustas cuando \"callas\"\\nporque estás como ausente...'"
+      ]
+     },
+     "execution_count": 36,
+     "metadata": {},
+     "output_type": "execute_result"
     }
    ],
    "source": [
-    "print(\"\"\"Me gustas cuando \"callas\"\n",
-    "porque estás como ausente...\"\"\")"
+    "\"\"\"Me gustas cuando \"callas\"\n",
+    "porque estás como ausente...\"\"\""
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 29,
+   "execution_count": 37,
    "metadata": {
     "collapsed": false
    },
@@ -645,41 +752,45 @@
        "'Me gustas cuando \"callas\"\\nporque estás como ausente...'"
       ]
      },
-     "execution_count": 29,
+     "execution_count": 37,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "poema = _\n",
-    "poema"
+    "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": 30,
+   "execution_count": 40,
    "metadata": {
     "collapsed": false
    },
    "outputs": [
     {
-     "data": {
-      "text/plain": [
-       "'Me gustas cuando \"callas\"\\nporque estás como ausente...'"
-      ]
-     },
-     "execution_count": 30,
-     "metadata": {},
-     "output_type": "execute_result"
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Me molestas cuando \"hablas\"\n",
+      "porque estás demasiado gritona...\n"
+     ]
     }
    ],
    "source": [
-    "_27"
+    "print(poema.replace('gustas', 'molestas').replace('callas', 'hablas').replace('como ausente', 'demasiado gritona'))"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 38,
+   "execution_count": 41,
    "metadata": {
     "collapsed": false
    },
@@ -687,46 +798,75 @@
     {
      "data": {
       "text/plain": [
-       "'-----------------------hola-----------------------'"
+       "\"o'higgings\""
       ]
      },
-     "execution_count": 38,
+     "execution_count": 41,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
-   "source": []
+   "source": [
+    "calle.lower()"
+   ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Las cadenas tienen sus propios **métodos**: pasar a mayúsculas, capitalizar, reemplazar una subcadena, etc. "
+    "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": 13,
+   "execution_count": 57,
    "metadata": {
     "collapsed": false
    },
    "outputs": [
     {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Me molestas cuando hablas\n",
-      "porque estás demasiado gritona...\n"
-     ]
+     "data": {
+      "text/plain": [
+       "'********************************************************************************'"
+      ]
+     },
+     "execution_count": 57,
+     "metadata": {},
+     "output_type": "execute_result"
     }
    ],
    "source": [
-    "print(poema.replace('gustas', 'molestas').replace('callas', 'hablas').replace('como ausente', 'demasiado gritona'))"
+    "\"*\" * 80    # repetición"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Para separar una cadena se usa el método `split`"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 39,
+   "execution_count": 96,
    "metadata": {
     "collapsed": false
    },
@@ -734,28 +874,28 @@
     {
      "data": {
       "text/plain": [
-       "\"o'higgings\\n\\n\\ndfdsfds\""
+       "['beso', 'a', 'beso,', 'me', 'enamoré', 'de', 'tí']"
       ]
      },
-     "execution_count": 39,
+     "execution_count": 96,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "calle.lower()"
+    "\"beso a beso, me enamoré de tí\".split(' ')   # devuelve una lista de cadenas (ya vemos más)"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "También se pueden concatenar"
+    "Y el método inverso es `join`, para unir muchas cadenas intercalandolas con otra"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 40,
+   "execution_count": 98,
    "metadata": {
     "collapsed": false
    },
@@ -763,30 +903,37 @@
     {
      "data": {
       "text/plain": [
-       "\"O'Higgings\\n\\n\\ndfdsfds fue un soldado de San Martín\""
+       "'y-jugando-al-amor-nos-encontró'"
       ]
      },
-     "execution_count": 40,
+     "execution_count": 98,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "calle + \" fue un soldado de San Martín\""
+    "\"-\".join(['y', 'jugando', 'al', 'amor', 'nos', 'encontró'])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Indizado y rebanado"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Pero las cadenas también son **secuencias**. O sea, conjuntos ordenados que se pueden indizar, recortar, reordenar, etc. \n",
+    "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": 43,
+   "execution_count": 89,
    "metadata": {
     "collapsed": false
    },
@@ -794,23 +941,71 @@
     {
      "data": {
       "text/plain": [
-       "'X'"
+       "'H'"
       ]
      },
-     "execution_count": 43,
+     "execution_count": 89,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "cadena = \"SLICEINDEX\"\n",
+    "cadena = \"HOLA MUNDO\"\n",
     "\n",
-    "cadena[-1]\n"
+    "cadena[0]     "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [],
+   "source": [
+    "cadena[5:-4]"
+   ]
+  },
+  {
+   "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": 93,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [
+    {
+     "ename": "TypeError",
+     "evalue": "'str' object does not support item assignment",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
+      "\u001b[1;32m<ipython-input-93-3dc4dfe33a69>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mcadena\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;34m'B'\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
+      "\u001b[1;31mTypeError\u001b[0m: 'str' object does not support item assignment"
+     ]
+    }
+   ],
+   "source": [
+    "cadena[0] = 'B'"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Pero si podemos basarnos en un string para crear otro"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 45,
+   "execution_count": 92,
    "metadata": {
     "collapsed": false
    },
@@ -818,21 +1013,21 @@
     {
      "data": {
       "text/plain": [
-       "'SLI'"
+       "'HOLA SUBMUNDO'"
       ]
      },
-     "execution_count": 45,
+     "execution_count": 92,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "cadena[:3]"
+    "cadena[:4] + \" SUB\" + cadena[5:]"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 48,
+   "execution_count": 56,
    "metadata": {
     "collapsed": false
    },
@@ -840,21 +1035,30 @@
     {
      "data": {
       "text/plain": [
-       "'I'"
+       "'ODNUM ALOH'"
       ]
      },
-     "execution_count": 48,
+     "execution_count": 56,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "cadena[5:-4]"
+    "cadena[::-1]   #wow!"
+   ]
+  },
+  {
+   "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": 49,
+   "execution_count": 99,
    "metadata": {
     "collapsed": false
    },
@@ -862,28 +1066,30 @@
     {
      "data": {
       "text/plain": [
-       "'SIENE'"
+       "10"
       ]
      },
-     "execution_count": 49,
+     "execution_count": 99,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "cadena[::2]   #wow!"
+    "len(cadena)"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Algunas operaciones"
+    "#### 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": 19,
+   "execution_count": 59,
    "metadata": {
     "collapsed": false
    },
@@ -891,21 +1097,43 @@
     {
      "data": {
       "text/plain": [
-       "'********************************************************************************'"
+       "\"O'Higgings fue soldado de san martín\""
       ]
      },
-     "execution_count": 19,
+     "execution_count": 59,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "\"*\" * 80    # repetición"
+    "\"{0} fue soldado de {1}\".format(calle, 'san martín')    # placeholders por posición de argumento"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 63,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'Hola Mundo'"
+      ]
+     },
+     "execution_count": 63,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "\"{saludo} {planeta}\".format(saludo='Hola', planeta='Mundo')    # placeholders por nombre de argumentos"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 53,
+   "execution_count": 85,
    "metadata": {
     "collapsed": false
    },
@@ -913,28 +1141,30 @@
     {
      "data": {
       "text/plain": [
-       "\"mundo era un groso del O'Higgings\\n\\n\\ndfdsfds\""
+       "'La parte real es 1.45015 y la imaginaria es 1.0'"
       ]
      },
-     "execution_count": 53,
+     "execution_count": 85,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "\"{1} era un groso del {0}\".format(calle, 'mundo') "
+    "\"La parte real es {0.real:.5f} y la imaginaria es {0.imag}\".format(resultado)"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Pero el **tipado es fuerte**. En general, los tipos no se convierten implícitamente"
+    "#### 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": 78,
+   "execution_count": 46,
    "metadata": {
     "collapsed": false
    },
@@ -945,7 +1175,7 @@
        "'22'"
       ]
      },
-     "execution_count": 78,
+     "execution_count": 46,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -956,7 +1186,29 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 55,
+   "execution_count": 86,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "4"
+      ]
+     },
+     "execution_count": 86,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "int(\"2\") + int(\"2\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 87,
    "metadata": {
     "collapsed": false
    },
@@ -964,18 +1216,47 @@
     {
      "data": {
       "text/plain": [
-       "3.2"
+       "2.34545"
       ]
      },
-     "execution_count": 55,
+     "execution_count": 87,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "float(\"1.2\") + 2"
+    "\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": []
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -987,7 +1268,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 56,
+   "execution_count": 106,
    "metadata": {
     "collapsed": false
    },
@@ -998,7 +1279,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 57,
+   "execution_count": 107,
    "metadata": {
     "collapsed": false
    },
@@ -1009,7 +1290,7 @@
        "list"
       ]
      },
-     "execution_count": 57,
+     "execution_count": 107,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1022,12 +1303,12 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Las listas tambien son secuencias"
+    "Las listas tambien son secuencias, por lo que el indizado y rebanado funciona igual"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 58,
+   "execution_count": 108,
    "metadata": {
     "collapsed": false
    },
@@ -1038,7 +1319,7 @@
        "'Melisa'"
       ]
      },
-     "execution_count": 58,
+     "execution_count": 108,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1049,7 +1330,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 59,
+   "execution_count": 109,
    "metadata": {
     "collapsed": false
    },
@@ -1060,7 +1341,7 @@
        "['Nadia', 'Daniel']"
       ]
      },
-     "execution_count": 59,
+     "execution_count": 109,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1078,7 +1359,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 60,
+   "execution_count": 123,
    "metadata": {
     "collapsed": false
    },
@@ -1089,7 +1370,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 61,
+   "execution_count": 124,
    "metadata": {
     "collapsed": false
    },
@@ -1098,7 +1379,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "[1.2, 'Jairo', 12000000.0, \"O'Higgings\\n\\n\\ndfdsfds\", 'Nadia']\n"
+      "[1.2, 'Jairo', 12000000.0, \"O'Higgings\", 'Nadia']\n"
      ]
     }
    ],
@@ -1115,7 +1396,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 62,
+   "execution_count": 125,
    "metadata": {
     "collapsed": false
    },
@@ -1134,7 +1415,7 @@
        "('Martín', 1.2, (1j, 'Melisa'))"
       ]
      },
-     "execution_count": 62,
+     "execution_count": 125,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1155,7 +1436,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 39,
+   "execution_count": 126,
    "metadata": {
     "collapsed": false
    },
@@ -1166,7 +1447,7 @@
        "[1.2, 'Jairo', 12000000.0, \"O'Higgings\", 'Nadia', 'otro elemento']"
       ]
      },
-     "execution_count": 39,
+     "execution_count": 126,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1178,7 +1459,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 40,
+   "execution_count": 127,
    "metadata": {
     "collapsed": false
    },
@@ -1189,7 +1470,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 41,
+   "execution_count": 128,
    "metadata": {
     "collapsed": false
    },
@@ -1200,7 +1481,7 @@
        "[1.2, 'Jairo', 12000000.0, \"O'Higgings\", 'Nadia', 'otra cosa']"
       ]
      },
-     "execution_count": 41,
+     "execution_count": 128,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1209,27 +1490,52 @@
     "mezcolanza"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Incluso se pueden hacer asignaciones de secuencias sobres \"slices\""
+   ]
+  },
   {
    "cell_type": "code",
-   "execution_count": 42,
+   "execution_count": 133,
    "metadata": {
     "collapsed": false
    },
    "outputs": [
     {
-     "ename": "TypeError",
-     "evalue": "'tuple' object does not support item assignment",
-     "output_type": "error",
-     "traceback": [
-      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
-      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
-      "\u001b[1;32m<ipython-input-42-a4cb4abacc8c>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0muna_tupla\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m-\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;34m\"osooo\"\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
-      "\u001b[1;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
-     ]
+     "data": {
+      "text/plain": [
+       "['A', 'B', 12000000.0, \"O'Higgings\", 'Nadia', 'otra cosa']"
+      ]
+     },
+     "execution_count": 133,
+     "metadata": {},
+     "output_type": "execute_result"
     }
    ],
    "source": [
-    "una_tupla[-1] = \"osooo\""
+    "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\""
    ]
   },
   {
@@ -1241,18 +1547,26 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 66,
+   "execution_count": 134,
    "metadata": {
     "collapsed": false
    },
    "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1\n",
+      "1\n"
+     ]
+    },
     {
      "data": {
       "text/plain": [
        "[1, 3, 4, 1, '8']"
       ]
      },
-     "execution_count": 66,
+     "execution_count": 134,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1260,7 +1574,8 @@
    "source": [
     "l = [1, 3, 4, 1]\n",
     "t = (1, 3, 1, 4)\n",
-    "l.count(3) == t.count(3)\n",
+    "print(l.count(3))\n",
+    "print(t.count(3))\n",
     "l.append('8')\n",
     "l"
    ]
@@ -1269,12 +1584,14 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
+    "#### packing/unpacking\n",
+    "\n",
     "Como toda secuencia, las listas y tuplas se pueden *desempacar*"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 67,
+   "execution_count": 136,
    "metadata": {
     "collapsed": false
    },
@@ -1283,32 +1600,22 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "10\n",
-      "Juan se sacó un  10\n"
+      "Juan se sacó un 10\n"
      ]
     }
    ],
    "source": [
     "nombre, nota = (\"Juan\", 10)\n",
-    "print(nota)\n",
-    "print(nombre,\"se sacó un \", nota)"
+    "print(\"{} se sacó un {}\".format(nombre, nota))     # igual a \"{0} se sacó un {1}\""
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 68,
+   "execution_count": null,
    "metadata": {
     "collapsed": false
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "2.0\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "a, b = 1, 2.0\n",
     "a, b = b, a\n",
@@ -1319,25 +1626,16 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Python 3 incorpora un desempacado extendido"
+    "Python 3 permite un desempacado extendido"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 69,
+   "execution_count": null,
    "metadata": {
     "collapsed": false
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "(1, 2, [3, 4, 5])\n",
-      "(1, [2, 3, 4], 5)\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "a, b, *c = [1, 2, 3, 4, 5]\n",
     "print((a, b, c))\n",
@@ -1347,19 +1645,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 71,
+   "execution_count": null,
    "metadata": {
     "collapsed": false
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "1 [2, 3, 4] 5\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "v = [1, 2, 3, 4, 5]\n",
     "a, b, c = (v[0], v[1:-1], v[-1])\n",
@@ -1375,29 +1665,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 162,
+   "execution_count": null,
    "metadata": {
     "collapsed": false
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[1, 3, 4]\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "(None, list)"
-      ]
-     },
-     "execution_count": 162,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "a = (1, 3, 4)\n",
     "b = list(a)\n",
@@ -1413,44 +1685,22 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 80,
+   "execution_count": null,
    "metadata": {
     "collapsed": false
    },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90, 95]"
-      ]
-     },
-     "execution_count": 80,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "list(range(0, 100, 5))"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 174,
+   "execution_count": null,
    "metadata": {
     "collapsed": false
    },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "range(0, 6)"
-      ]
-     },
-     "execution_count": 174,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "range(6)"
    ]
@@ -1468,22 +1718,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 180,
+   "execution_count": null,
    "metadata": {
     "collapsed": false
    },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "range(0, 25, 5)"
-      ]
-     },
-     "execution_count": 180,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "range(0, 25, 5)"
    ]
@@ -1508,22 +1747,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 81,
+   "execution_count": null,
    "metadata": {
     "collapsed": false
    },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "21.36"
-      ]
-     },
-     "execution_count": 81,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "sum([1, 5.36, 5, 10])"
    ]
@@ -1537,22 +1765,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 85,
+   "execution_count": null,
    "metadata": {
     "collapsed": false
    },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "0"
-      ]
-     },
-     "execution_count": 85,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "a = [1, 'hola', []]\n",
     "a.index(1)"
@@ -1567,19 +1784,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 86,
+   "execution_count": null,
    "metadata": {
     "collapsed": false
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[[], 'hola', 1]\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "a.reverse()\n",
     "print(a)"
@@ -1594,22 +1803,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 87,
+   "execution_count": null,
    "metadata": {
     "collapsed": false
    },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[1, 'hola', []]"
-      ]
-     },
-     "execution_count": 87,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "b = list(reversed(a))\n",
     "b"
@@ -1626,24 +1824,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 90,
+   "execution_count": null,
    "metadata": {
     "collapsed": false
    },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[('Juan', 'cerveza', 'arg'),\n",
-       " ('Martín', 'boca juniors', 'chi'),\n",
-       " ('María', 'lechuga', 'ita')]"
-      ]
-     },
-     "execution_count": 90,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "nombres = ['Juan', 'Martín', 'María']\n",
     "pasiones = ['cerveza', 'boca juniors', 'lechuga', 1]\n",
@@ -1657,29 +1842,12 @@
    "source": [
     "#### Ejercicios\n",
     "\n",
-    "- Resuelva la siguiente operación $$\\frac{(\\sum_{k=0}^{100}k)^3}{2}$$"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 92,
-   "metadata": {
-    "collapsed": false
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "64393812500.0"
-      ]
-     },
-     "execution_count": 92,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "(sum(range(0, 101))**3)/2"
+    "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"
    ]
   },
   {
@@ -1702,7 +1870,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 94,
+   "execution_count": 163,
    "metadata": {
     "collapsed": false
    },
@@ -1711,8 +1879,8 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "edad: 25\n",
-      "Bienvenido, jovato\n"
+      "edad: 4\n",
+      "Usted es menor de edad. Raje de acá, pendejo\n"
      ]
     }
    ],
@@ -1721,7 +1889,7 @@
     "if edad < 18:\n",
     "    print(\"Usted es menor de edad. Raje de acá, pendejo\")    \n",
     "else:\n",
-    "    print(\"Bienvenido, jovato\")\n"
+    "    print(\"Bienvenido, jovatón\")\n"
    ]
   },
   {
@@ -1751,19 +1919,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 95,
+   "execution_count": null,
    "metadata": {
     "collapsed": false
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "No seré feliz pero tengo marido\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "if edad < 12:\n",
     "    print(\"Feliz dia del niño\")\n",
@@ -1777,22 +1937,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 99,
+   "execution_count": null,
    "metadata": {
     "collapsed": false
    },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "bool"
-      ]
-     },
-     "execution_count": 99,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "type(edad < 12)"
    ]
@@ -1801,24 +1950,16 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "En un `if`, la conversión a tipo *boolean* es implícita. El tipo `None` (vació), 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``."
+    "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": 207,
+   "execution_count": null,
    "metadata": {
     "collapsed": false
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Dio cero\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "if 5 - 5: \n",
     "    a = \"No es cero\"\n",
@@ -1836,24 +1977,29 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 101,
+   "execution_count": null,
    "metadata": {
     "collapsed": false
    },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "dio cero\n"
-     ]
-    }
-   ],
+   "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\n",
+    "\n",
+    "$$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": {},
@@ -1865,22 +2011,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 102,
+   "execution_count": null,
    "metadata": {
     "collapsed": false
    },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "6.6"
-      ]
-     },
-     "execution_count": 102,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "sumatoria = 0\n",
     "for elemento in [1, 2, 3.6]:\n",
@@ -1897,21 +2032,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 104,
+   "execution_count": null,
    "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"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "for posicion, valor in enumerate([4, 3, 19]):\n",
     "    print(\"El valor de la posicion %s es %d\" % (posicion, valor))"
@@ -1926,22 +2051,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 105,
+   "execution_count": null,
    "metadata": {
     "collapsed": false
    },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(5050, 101)"
-      ]
-     },
-     "execution_count": 105,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "sumatoria = 0\n",
     "for elemento in range(1000):\n",
@@ -1960,38 +2074,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 229,
+   "execution_count": null,
    "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": 229,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "sumatoria = 0\n",
     "for elemento in range(20):\n",
@@ -2011,19 +2098,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 106,
+   "execution_count": null,
    "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"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "cuadrados = []\n",
     "for i in range(-3,15,1):\n",
@@ -2040,22 +2119,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 110,
+   "execution_count": null,
    "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": 110,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "[i**2 for i in range(-3,15,1)]"
    ]
@@ -2064,41 +2132,31 @@
    "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. Por ejemplo, obtener la sumatoria de los cubos de los numeros impares menores a 10. $$\\sum_{a=0}^{9}a^3 \\mid a\\ impar $$"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 112,
-   "metadata": {
-    "collapsed": false
-   },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[1, 3, 5, 7, 9]"
-      ]
-     },
-     "execution_count": 112,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "list(range(1, 10, 2))"
+    "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": "markdown",
    "metadata": {},
    "source": [
-    "La misma sintaxis funciona sin tener que hacer listas: se crean *generadores*, que son tipos de datos iterables pero no indizables (es el mismo tipo de objeto que devuelve `reversed`, que ya vimos). Si es para *recorrer* todos los elementos de corrido son mucho más eficientes."
+    "#### 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": 243,
+   "execution_count": 138,
    "metadata": {
     "collapsed": false
    },
@@ -2106,52 +2164,51 @@
     {
      "data": {
       "text/plain": [
-       "<generator object <genexpr> at 0x7f643f321eb0>"
+       "<generator object <genexpr> at 0x7fc55c0d6678>"
       ]
      },
-     "execution_count": 243,
+     "execution_count": 138,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "(a**3 for a in range(10) if a % 2 == 1)"
+    "(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": 244,
+   "execution_count": null,
    "metadata": {
     "collapsed": false
    },
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "1225"
-      ]
-     },
-     "execution_count": 244,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
-    "sum(a**3 for a in range(10) if a % 2 == 1)"
+    "a = 0\n",
+    "while a < 10:\n",
+    "    print (a)\n",
+    "    a += 1"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "#### While\n",
-    "\n",
-    "Otro tipo de sentencia de control es *while*: iterar mientras se cumpla una condición"
+    "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": 250,
+   "execution_count": 148,
    "metadata": {
     "collapsed": false
    },
@@ -2160,36 +2217,31 @@
      "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"
+      "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?\n",
+      "4 elefantes se balanceaban sobre la tela de una araña\n",
+      "Desea invitar a otro elefante?sdsd\n",
+      "5 elefantes se balanceaban sobre la tela de una araña\n",
+      "Desea invitar a otro elefante?no\n"
      ]
     }
    ],
    "source": [
-    "a = 0\n",
-    "while a < 10:\n",
-    "    print (a)\n",
-    "    a += 1"
+    "n = 1\n",
+    "while True:\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": [
-    "#### Ejercicios\n",
-    "\n",
-    "\n",
-    "- Encuentre el mínimo de $$f(x) = (x-4)^2-3 \\mid x \\in  [-100, 100)$$ \n",
-    "- Encuentre el promedio de los números reales de la cadena `\"3,4   1,2  -6   0  9,7\"`. Podes usar el método `split()` para separa la cadena por espacios en blanco"
-   ]
+   "source": []
   },
   {
    "cell_type": "code",
@@ -2206,20 +2258,20 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### Más estructuras: diccionarios y conjuntos\n",
+    "### 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": 113,
+   "execution_count": 150,
    "metadata": {
     "collapsed": false
    },
    "outputs": [],
    "source": [
-    "camisetas = {'Orión': 1, 'Osvaldo': 9, 'Gago': 5, 'Gaitán': 'Jugador nº 12'} "
+    "camisetas = {'Orión': 1, 'Carlitos': 9, 'Gago': 5, 'Gaitán': 'Jugador nº 12'} "
    ]
   },
   {
@@ -2231,7 +2283,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 117,
+   "execution_count": 152,
    "metadata": {
     "collapsed": false
    },
@@ -2242,13 +2294,13 @@
        "'callejero'"
       ]
      },
-     "execution_count": 117,
+     "execution_count": 152,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "camisetas['Osvaldo']\n",
+    "camisetas['Carlitos']\n",
     "\n",
     "animales = {'felinos': {'gatos': ['callejero', 'pardo']}}\n",
     "             \n",
@@ -2267,7 +2319,85 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 118,
+   "execution_count": null,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [],
+   "source": [
+    "sorted(camisetas.keys())"
+   ]
+  },
+  {
+   "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": null,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [],
+   "source": [
+    "camisetas['Lodeiro'] = 10\n",
+    "camisetas['Lodeiro']\n",
+    "\n",
+    "list(camisetas.items())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Hay muchos *métodos* útiles"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [],
+   "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": null,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [],
+   "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": 155,
    "metadata": {
     "collapsed": false
    },
@@ -2275,28 +2405,76 @@
     {
      "data": {
       "text/plain": [
-       "['Gago', 'Gaitán', 'Orión', 'Osvaldo']"
+       "{'Mariano': 'nano@email.com', 'Martin': 'tin@email.com'}"
       ]
      },
-     "execution_count": 118,
+     "execution_count": 155,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "sorted(camisetas.keys())"
+    "nombres = \"Martin\", \"Mariano\"\n",
+    "emails = \"tin@email.com\", \"nano@email.com\"\n",
+    "\n",
+    "dict(zip(nombres, emails))"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Los diccionarios **son mutables**. Es decir, podemos cambiar el valor de una clave, agregar o quitar.  "
+    "#### 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": "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": 123,
+   "execution_count": 169,
+   "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": 162,
    "metadata": {
     "collapsed": false
    },
@@ -2304,67 +2482,50 @@
     {
      "data": {
       "text/plain": [
-       "[('Gaitán', 'Jugador nº 12'),\n",
-       " ('Orión', 1),\n",
-       " ('Osvaldo', 9),\n",
-       " ('Lodeiro', 10),\n",
-       " ('Gago', 5)]"
+       "{'gato', 'leon', 'perro'}"
       ]
      },
-     "execution_count": 123,
+     "execution_count": 162,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "camisetas['Lodeiro'] = 10\n",
-    "camisetas['Lodeiro']\n",
-    "\n",
-    "list(camisetas.items())"
+    "mamiferos"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Hay muchos *métodos* útiles"
+    "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": 124,
+   "execution_count": 158,
    "metadata": {
     "collapsed": false
    },
    "outputs": [
     {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Orión lleva la 1\n",
-      "Osvaldo lleva la 9\n",
-      "Lodeiro lleva la 10\n",
-      "Gago lleva la 5\n"
-     ]
+     "data": {
+      "text/plain": [
+       "{'gato', 'perro'}"
+      ]
+     },
+     "execution_count": 158,
+     "metadata": {},
+     "output_type": "execute_result"
     }
    ],
    "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)` con el construcutor `dict()`"
+    "mamiferos.intersection(domesticos)    #  mamiferos & domesticos"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 125,
+   "execution_count": 159,
    "metadata": {
     "collapsed": false
    },
@@ -2372,23 +2533,21 @@
     {
      "data": {
       "text/plain": [
-       "{'Cismondi': 'cismondi@phasety.com',\n",
-       " 'Melisa': 'mgomez@phasety.com',\n",
-       " 'Yo': 'gaitan@gmail.com'}"
+       "{'gallina', 'gato', 'leon', 'perro'}"
       ]
      },
-     "execution_count": 125,
+     "execution_count": 159,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "dict([('Yo', 'gaitan@gmail.com'), ('Melisa', 'mgomez@phasety.com'), ('Cismondi', 'cismondi@phasety.com')])"
+    "mamiferos.union(domesticos)     #  mamiferos | domesticos"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 126,
+   "execution_count": 160,
    "metadata": {
     "collapsed": false
    },
@@ -2396,55 +2555,72 @@
     {
      "data": {
       "text/plain": [
-       "{'nano': 'el@', 'tin': 'yo@'}"
+       "{'colibrí', 'halcón'}"
       ]
      },
-     "execution_count": 126,
+     "execution_count": 160,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "nombres = \"tin\", \"nano\"\n",
-    "emails = \"yo@\", \"el@\"\n",
-    "\n",
-    "dict(zip(nombres, emails))"
+    "aves.difference(domesticos)     # mamiferos - domesticos"
    ]
   },
   {
-   "cell_type": "markdown",
-   "metadata": {},
+   "cell_type": "code",
+   "execution_count": 171,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'gallina', 'leon'}"
+      ]
+     },
+     "execution_count": 171,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
-    "Que es muy útil usar con la función `zip()` que ya vimos"
+    "mamiferos.symmetric_difference(domesticos)    # mamiferos ^ domesticos"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Los diccionarios son super útiles, recuerdenlos!\n",
-    "\n",
-    "#### Conjuntos\n",
-    "\n",
-    "Los conjuntos (`set()`) son grupos de claves únicas e inmutables."
+    "Se puede comparar pertenencia de elementos y subconjuntos"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 127,
+   "execution_count": 173,
    "metadata": {
     "collapsed": false
    },
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "True"
+      ]
+     },
+     "execution_count": 173,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
-    "mamiferos = set(['perro', 'gato', 'leon'])\n",
-    "domesticos = {'perro', 'gato', 'gallina'}\n",
-    "aves = {'gallina', 'halcón', 'colibrí'}"
+    "'gato' in mamiferos"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 128,
+   "execution_count": 174,
    "metadata": {
     "collapsed": false
    },
@@ -2452,21 +2628,28 @@
     {
      "data": {
       "text/plain": [
-       "{'gato', 'perro'}"
+       "False"
       ]
      },
-     "execution_count": 128,
+     "execution_count": 174,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "mamiferos.intersection(domesticos)"
+    "domesticos.issubset(mamiferos)  "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Además, tienen métodos para agregar o extraer elementos"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 129,
+   "execution_count": 165,
    "metadata": {
     "collapsed": false
    },
@@ -2474,21 +2657,29 @@
     {
      "data": {
       "text/plain": [
-       "{'gallina', 'gato', 'leon', 'perro'}"
+       "{'elefante', 'gato', 'leon', 'perro'}"
       ]
      },
-     "execution_count": 129,
+     "execution_count": 165,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "mamiferos.union(domesticos)"
+    "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": 130,
+   "execution_count": 167,
    "metadata": {
     "collapsed": false
    },
@@ -2496,16 +2687,34 @@
     {
      "data": {
       "text/plain": [
-       "{'colibrí', 'halcón'}"
+       "{1, 2, 3}"
       ]
      },
-     "execution_count": 130,
+     "execution_count": 167,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "aves.difference(domesticos)"
+    "set([1, 2, 3, 2, 1, 3])"
+   ]
+  },
+  {
+   "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"
    ]
   },
   {
@@ -2534,7 +2743,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.4.2"
+   "version": "3.4.0"
   }
  },
  "nbformat": 4,
diff --git a/img/index_slicing.png b/img/index_slicing.png
index 796ed7d..c780487 100644
Binary files a/img/index_slicing.png and b/img/index_slicing.png differ