00_Python_y_EDA.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Estadística, ciencia de datos y análisis de datos\n",
    "\n",
    "El objetivo de este primer capítulo es introducir algunos términos y conceptos generales de estadística, que nos serán de utilidad para discutir todos los tópicos de este curso y de posteriores cursos de este Programa de Actualización en Ciencia de Datos. La introducción es bastante general, por lo que a lo largo del texto se proveen de enlaces para seguir leyendo y profundizando en el tema."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Estadística y ciencia de datos ¿Dos nombres para lo mismo?\n",
    "\n",
    "La [estadística](https://es.wikipedia.org/wiki/Estad%C3%ADstica) es el estudio de la recolección, análisis, interpretación y organización de datos. El corolario de esta definición podría ser que además de ser una disciplina científica en si misma, la estadística es una disciplina auxiliar de todas las demás ciencias.\n",
    "\n",
    "La estadística suele tener el mote de ser una disciplina obscura en el mejor de los casos y de una forma sofisticada de mentir en el peor de ellos. Sin embargo, en los últimos años ha comenzado a emerger una disciplina llamada ciencia de datos (_data science_ en inglés), para muchos no es más que un nuevo y [sexy](https://hbr.org/2012/10/data-scientist-the-sexiest-job-of-the-21st-century/) nombre para llamar a la vieja estadística, algo así como una campaña mediática de mejoramiento de imagen. Para otros la ciencia de datos es un aporte valioso que si bien no es exactamente estadística, está contribuyendo a ésta con nuevos métodos, aproximaciones, preguntas, recursos ($$) y por supuesto mucha gente interesada en estos temas.\n",
    "\n",
    "Una posible definición de la ciencia de datos y su relación con la estadística se muestra en el siguiente diagrama de Venn. \n",
    "\n",
    "<a href=\"http://drewconway.com/zia/2013/3/26/the-data-science-venn-diagram\">\n",
    "<img src='imagenes/DS.png' width=300 >\n",
    "</a>\n",
    "\n",
    "Según el diagrama, la estadística es una de las partes de la ciencia de datos. La gran diferencia entre la investigación tradicional y la ciencia de datos radica no en los conocimientos estadísticos (que ambas requieren) si no en las habilidades de _hacking_. En esto contexto _hacking_ no hace referencia a la capacidad de vulnerar la seguridad de computadoras ajenas, si no a _la capacidad técnica y creativa para encontrar soluciones mediante el uso de código_. \n",
    "\n",
    "Entonces, para empezar a hacer ciencia de datos necesitamos (además de un problema!):\n",
    "\n",
    "* Nociones básicas de programación.\n",
    "* Nociones básicas de estadística.\n",
    "\n",
    "En este curso aprenderemos ambas en paralelo. Esto puede sonar complicado, pero en realidad ambos aprendizajes se acompañan y apuntalan mutuamente. La mejor forma de probar que esto es cierto es hacer el curso, pero como adelanto podemos decir que esto funciona debido a que:\n",
    "\n",
    "* Aprender a programar sin tener un problema que resolver puede ser, para la mayoría de las personas, una tarea demasiado abstracta y poco placentera. El aprendizaje de la estadística nos proveerá de estos problemas.\n",
    "\n",
    "* La conceptos estadísticos tienen una fundamentación matemática que suele requerir de cierta formación matemática que no es común a la mayoría de los científicos. El manejo de un lenguaje de programación provee una ruta alternativa (o complementaria), ya que nos permite comprender conceptos vía la simulación/experimentación.\n",
    "\n",
    "Volviendo al diagrama de Venn, tanto la investigación tradicional como la ciencia de datos necesitan ir acompañadas de _conocimiento sustantivo_, esto hace referencia al conocimiento de una área particular del saber. La estadística puede ser de ayuda para estudiar genomas o partículas elementales, pero para poder hacer preguntas relevantes (y entender las respuestas) primero hay que comprender qué son los genomas y qué son las partículas elementales.\n",
    "La estadística NO es una máquina auto-mágica por donde entran datos en crudo por un lado y sale información por el otro (aunque a veces se publicite de esa forma). La estadística es una herramienta que nos ayuda a pensar y tomar decisiones de forma adecuada, pero requiere del conocimiento, el criterio y la responsabilidad de quien la usa."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python\n",
    "\n",
    "El lenguaje de programación elegido para este curso es Python.\n",
    "\n",
    "[Python](http://www.python.org/) es:\n",
    "* Es un lenguaje simple: El código es simple de leer, de escribir y de mantener.\n",
    "* De propósito general (se suele decir que Python no es el mejor lenguaje para casi nada, pero es suficientemente bueno para casi todo)\n",
    "* Multiparadigma (es posible programar usando distintos _estilos_ de programación incluso combinándolos)\n",
    "* De alto nivel (es decir cercano al lenguaje humano y lejos del _lenguaje de máquinas_)\n",
    "* Es interpretado (es decir no es necesario _compilarlo_ antes de correrlo)\n",
    "* Es multiplataforma (corre en diversos sistemas operativos)\n",
    "* Es gratuito y es una herramienta de [código abierto](https://es.wikipedia.org/wiki/C%C3%B3digo_abierto).\n",
    "* Está muy bien documentado.\n",
    "* Es ampliamente usado en la mayoría de las disciplinas científicas\n",
    "* Tiene una gran comunidad de usuarios (no todos científicos), por lo que es fácil encontrar ayuda, tutoriales, foros, blogs, etc. Por ejemplo en [StackOverflow](stackoverflow.com) o en telegram (@Python_cientifico)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Análisis exploratorio de datos\n",
    "\n",
    "Para poder empezar a analizar datos lo que primero que hay que tener es...datos! Estos datos provienen de experimentos, simulaciones, encuestas, observaciones, búsquedas en base de datos, etc. Rara vez los datos se nos presentan de forma inmaculada y lista para usar, por lo general hay que limpiarlos, procesarlos, combinarlos con datos de otras fuentes etc. Para sorpresa y frustración (sobre todo frustración) de quienes se inician en el análisis de datos esta etapa suele ser la que más tiempo involucra. En este curso veremos algunos rudimentos básicos de como hacer estas tareas.\n",
    "\n",
    "Suponiendo que ya tenemos nuestros datos, lo recomendable es intentar _ganar intuición_ sobre los datos que tenemos enfrente, tratar de ver _qué dicen_ de nuestro problema, si es que dicen algo. Para ello se han desarrollado una colección de métricas y métodos colectivamente llamados [Análisis exploratorio de datos](https://en.wikipedia.org/wiki/Exploratory_data_analysis) (EDA por sus siglas en inglés), la cual se compone básicamente de dos herramientas complementarias:\n",
    "\n",
    "1. La estadística descriptiva \n",
    "1. La visualización de datos\n",
    "\n",
    "La primera se ocupa de describir de forma cuantitativa un conjunto de datos. Para ello se recurre a un conjunto de medidas que nos ayudan a resumir los datos en unos pocos números. En general se habla de medidas de centralidad, de dispersión y con menor frecuencia se suele hablar de medidas de forma.\n",
    "La segunda se encarga de mostrar los datos de forma que sea más fácil interpretarlos. Los seres humanos tenemos un sistema visual muy poderoso y la visualización de datos intenta aprovechar sus virtudes a la vez que mitigar sus defectos."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tipos de variables: Métricas, ordinales y categóricas\n",
    "\n",
    "Tanto en análisis de datos como en programación se habla de  _variables_, aunque el significado no es exactamente el mismo, veamos:\n",
    "\n",
    "En estadística una variable es simplemente una cantidad que puede tomar más de un valor. Las variables se suelen clasificar de la siguiente manera (aunque hay otras clasificaciones):\n",
    "\n",
    "* Métricas o cuantitativas: Son variables con las cuales es posible establecer un orden y computar distancias. Cuando en la escala existe un cero es posible además calcular proporciones, por ejemplo 1 hora es la mitad de 2 horas (por que 0 horas implica la ausencia de tiempo transcurrido). En cambio $40 ^\\circ \\text{C}$ no es el doble de $20 ^\\circ \\text{C}$, por que el cero de la escala Celcius es un punto totalmente arbitrario (contrario al cero de la escala Kelvin).\n",
    "    * Continuas: Se describen usando el conjunto de los reales, algunos ejemplos son la temperatura, altura, peso, etc.\n",
    "    * Discretas: Se describen usando el conjunto de los enteros, cantidad de hijos, de aviones de una aerolínea, etc.\n",
    "\n",
    "* Cualitativas: Son el tipo de variables que indican cualidades, o atributos.\n",
    "    * Categóricas o nominales: Son variables que indican pertenencia a categorías mutuamente excluyentes, como cara o ceca en una moneda. Aún cuando se usen números como 1 y 0 para representar este tipo de variables no se puede establecer orden alguno, \"cara\" no es más o menos que \"ceca\", ni \"ceca\" viene antes que \"cara\". Las variables categóricas no tienen por que ser dos, pueden ser millones, como los colores.\n",
    "    * Ordinales: La variable puede tomar distintos valores ordenados siguiendo una escala establecida, aunque el intervalo no tiene por que ser uniforme, por ejemplo en una carrera de bicicletas, la distancia entre la primer y segunda competidora no tiene por que ser la misma que entre la segunda y la tercera.\n",
    "    \n",
    "En Python, como en otros lenguajes de programación, se le llama variable a un espacio en la memoria de la computadora que almacena un valor determinado y que tiene asociado un identificador, es decir un rótulo o nombre. Existen distintos \"tipos\" de variable, en Python los tipos más comunes que encontraremos serán:\n",
    "\n",
    "* int : que corresponde a los números enteros. Por ej 42, 1, -4.\n",
    "* float : son una aproximación de los números reales por ej 3.14, 1.0, -0.124.\n",
    "* string : que corresponde a \"letras\" o _cadenas_ de letras y se escriben usando comillas dobles \"\" o simples ''. Por ejemplo 'hola', '42', 's'.\n",
    "* bool : Se corresponde con los booleanos. Sólo hay dos valores posibles True y False.\n",
    "\n",
    "Para saber el tipo de una variable en Python podemos usar la función `type()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(42)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(42.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(\"42\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "bool"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Existen muchos otros \"tipos\" de variables en Python, incluso los usuarios avanzados pueden crear sus propios tipos de variables! Por ahora estos tipos son suficientes. Tener variables es útil por que con ellas podemos hacer operaciones, por ejemplo operaciones matemáticas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 + 1 # esto devuelve un entero"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.0"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1. + 1  # esto devuelve un float"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.0"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 / 1  # en Python3 la división siempre devuelve floats"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "must be str, not int",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-8-291d8d83b47b>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;34m\"42\"\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;36m1\u001b[0m  \u001b[0;31m# esta operación no tiene sentido y por lo tanto Python devuelve un error!\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: must be str, not int"
     ]
    }
   ],
   "source": [
    "\"42\" + 1  # esta operación no tiene sentido y por lo tanto Python devuelve un error!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'4444'"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'4' * 4  # esta operación SI tiene sentido en Python, es lo que esperabas?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 > 2  # acá comparamos variables y obtenemos un booleano"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 == 2  # ojo que el operador \"igualdad\" es \"==\" y no \"=\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En los ejemplos anteriores hemos realizado algunas operaciones con variables, pero no las hemos guardado en ningún lado! Puede no ser obvio al principio pero para poder hacer tareas más complejas es necesario poder guardar variables y ponerles nombres (el indentificador al que hacíamos referencia antes). De esa forma podemos realizar una operación, como por ejemplo `2 + 2` y guardar el resultado bajo algún nombre para luego usarlo cuando lo necesitemos.\n",
    "\n",
    "Los nombres de las variables en Python siguen ciertas reglas que es necesario respetar.\n",
    "\n",
    "* Deben comenzar con _letras_ o con un `_`\n",
    "* La _letras_ pueden corresponderse con los caracteres `a-z`, `A-Z`\n",
    "* También podemos usar numeros `0-9` (solo que no como primer carácter). \n",
    "\n",
    "Python 3 permite además usar otros caracteres, como por ejemplo letras griegas, la `ñ`, caracteres acentuados, etc; aunque el uso de este tipo de caracteres para nombrar variables no esta muy difundido aún.\n",
    "\n",
    "Por convención, los nombres de las variables comienzan con una letra minúscula, los nombres de las funciones (ver más adelante) también, mientras que los nombres de las _clases_ (ver más adelante) comienzan con una letra mayúscula.\n",
    "\n",
    "\n",
    "Para asignarle un valor a una variable se usa el símbolo `=`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a = 2 + 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Al escribir esto le estamos diciendo a Python tome el valor `2` súmele el valor `3` y guárdelo en la variable que se llama `a`. Esto lo podemos comprobar de la siguiente forma:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "No solo es posible usar variables para guardar valores, también podemos operar con ellas! Por ejemplo podemos preguntar si nuestra variable es _mayor que_ cierto valor."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a > 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O podemos restarle un valor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a - 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Incluso podemos actualizar el valor de las variables, por ej."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = a + 1\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El ejemplo anterior muestra que el signo `=` no es el operador igualdad (que como vimos es `==`). No es correcto decir que `a` es igual a `a + 1` (aunque si nos expresamos de esa forma lo más probable es que nos entiendan). \n",
    "\n",
    "Si tuvieramos que leer la celda anterior en voz alta diríamos: tome el valor de la variable `a`, súmele `1` y guarde el resultado en la variable `a`.\n",
    "\n",
    "Si tratamos de usar una variable que no ha sido definida previamente obtendremos un mensaje de error:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'z' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-8-a8a78d0ff555>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mz\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m: name 'z' is not defined"
     ]
    }
   ],
   "source": [
    "z"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Los errores son parte central de la programación y hay que acostumbrarse a cometerlos ya que es así como se avanza en la escritura de un programa. Al producirse errores, Python entrega mensajes que son muy informativos y por lo tanto útiles para solucionar el error, por lo que es muy beneficioso aprender a interpretarlos y prestarles mucha atención cuando ocurren.   \n",
    "\n",
    "El proceso de corrección de errores de un programa se llama _debugging_ y es quizá una de las tareas más demandantes al escribir código. Python fue pensado como un lenguaje fácil de leer debido a que en general uno pasa más tiempo leyendo código (para arreglar los errores) que escribiéndolo. Mitad broma, mitad en serio se dice que si el _debugging_ es el proceso por el cual se eliminan errores la _programación_ debe ser el proceso por el cual se introducen los errores.\n",
    "\n",
    "Nota: en muchos lenguajes de programación (como C/C++ o Fortran) antes de poder asignar valores a variables es necesario declararlas. Declararlas, quiere decir que tenemos que indicar que nuestro programa usará una variable de nombre _tal_ que será del tipo _cual_. Recién una vez declarada la variable podemos asignarle valores concretos. En Python esto no es necesario, además en Python está permitido cambiar el tipo de una variable, por ejemplo podemos usar la variable `a` que hacía referencia a enteros (int) para referirnos a un string. El nombre técnico de esto es el de _tipado dinámico_ (el tipo de una variable no es fijo, si no dinámico)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a = '42'\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-27-71c695973ebe>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-27-71c695973ebe>\"\u001b[1;36m, line \u001b[1;32m1\u001b[0m\n\u001b[1;33m    Puede parecer poco lo que hemos aprendido hasta ahora, pero ya sabemos suficiente Python como para hacer algunos cálculos. Nada mejor para aprender a programar que intentar solucionar problemas. Un problema que podemos resolver con lo que sabemos de Python es calcular el valor de la media de un conjunto de valores.\u001b[0m\n\u001b[1;37m                ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "Puede parecer poco lo que hemos aprendido hasta ahora, pero ya sabemos suficiente Python como para hacer algunos cálculos. Nada mejor para aprender a programar que intentar solucionar problemas. Un problema que podemos resolver con lo que sabemos de Python es calcular el valor de la media de un conjunto de valores. \n",
    "\n",
    "Una forma fácil de perder tiempo al intentar resolver problemas es no tener demasiado claro cual es el problema que se intenta solucionar, asi que antes de calcular la media veamos primero que se entiende por _media_."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Medidas de  centralidad\n",
    "\n",
    "### Media\n",
    "\n",
    "Uno de los cómputos más elementales en estadística consiste en calcular la media, también conocido como promedio o valor esperado. Existen varias expresiones matemáticas que nos permiten calcular la media, quizá la más común sea:\n",
    "\n",
    "$$E[\\mathbf{x}] = \\frac{1}{n} \\sum_{i=1}^n{x_i}$$\n",
    "\n",
    "Es decir, para obtener la media de $n$ valores, los sumamos y luego dividimos en $n$. En estadística se suele usar la notación $E[\\mathbf{x}]$ nomo una forma abreviada de referirse a la media (o valor esperado) de $\\mathbf{x}$. Es común en estadística distinguir entre la media de una muestra, es decir de un conjunto finito de datos, y llamarla $\\bar x$ y la media de la población y llamarla $\\mu$, en la mayoría de los casos la población es un objeto imaginario al que no tenemos acceso y que solo aproximamos, en la gran mayoría de los casos $\\bar x$ es un _buen_ estimador de $\\mu$, por ejemplo a medida que juntemos más y más datos el valor de $\\bar x$ se aproximará al de $\\mu$.\n",
    "\n",
    "Dado un conjunto de valores, por ejemplo $\\mathcal{D} = \\{1, 2, 3, 4, 5, 6\\}$, una forma de calcular la media, usando Python, es:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.5"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "media = (1 + 2 + 3 + 4 + 5 + 6) / 6\n",
    "media"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El código que acabamos de escribir no difiere mucho de lo que podríamos haber realizado con una calculadora, primero tenemos que ingresar los numeros _a mano_ y además tenemos que saber exactamente la cantidad de números que estamos sumando para luego saber por que cantidad dividir. Usando un lenguaje de programación podemos hacer algo bastante más cómodo. Pero para ello tenemos que aprender un par de conceptos nuevos."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Listas\n",
    "\n",
    "Las listas de Python son un tipo de objeto que permite almacenar otros objetos, por ejemplo números. Gran parte de la programación en Python implica crear y manipular listas.\n",
    "\n",
    "La sintaxis para crear listas en Python es _[..., ..., ...]_:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lista = [] # crea una lista vacia\n",
    "lista"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "([1, 2, 3, 4, 5, 6], list)"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "num = [1, 2, 3, 4, 5, 6]\n",
    "num, type(num)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Las listas son un tipo particular de lo que se conoce genéricamente como _estructuras de datos_, es decir una forma particular de organizar y almacenar datos de forma que sea _conveniente_ trabajar con esos datos. Las listas de Python son _convenientes_ por que permiten no solo almacenar datos sino realizar muchas otras operaciones de forma sencilla. Una operación común es preguntarle a una lista cuantos valores contiene. Esto se hace con la función `len()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(lista)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(num)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Otra operación _conveniente_ es la de sumar todos los valores de una lista, esto lo hacemos usando la función `sum()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "21"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(num)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Estas dos funciones sobre listas nos permiten re-escribir el cálculo de una media, de la siguiente forma:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.5"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "media = sum(num) / len(num)\n",
    "media"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Esta nueva forma de calcular medias tiene varias ventajas. Una de ellas es que resulta más automática que la anterior, cada vez que cambiemos los valores contenidos en la lista `num` podremos ejecutar la celda anterior y obtener el valor de la media. Este es un buen momento para probar que esto es cierto. \n",
    "\n",
    "El código de la celda anterior es mucho más general que nuestra primer versión del cómputo de la media. Pero tiene un inconveniente, veamos. Es común al escribir código que necesitemos repetir una operación muchas veces, una solución simple sería copiar y pegar el código cada vez que necesitemos calcular una media. El problema con esta aproximación es que es tediosa, y es propensa a cometer errores, piensen que operaciones más complejas podrían requerir de cientos de líneas de código, no una sola como el ejemplo de la media. Una forma de resolver nuestro problema sería crear una _función_ que calcule la media, de tal forma que podamos _llamar_ a esa función cada vez que la necesitemos. En Python crear funciones es muy simple, veamos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def calcular_media(a):\n",
    "    res = sum(a) / len(a)\n",
    "    return res"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. En la primer linea podemos ver que para definir una función necesitamos la palabra reservada `def`. Le llamamos _reservada_ porque tiene significado especial para Python y no deberíamos usar ese nombre para otra cosa que no sea definir funciones. \n",
    "2. Luego de `def` va el nombre de la función, que puede ser el que más nos guste (siempre que respetemos las reglas para nombrar funciones, que son las mismas que para nombrar variables).\n",
    "3. Entre paréntesis los nombres de los _argumentos_ de la función.\n",
    "4. Cerramos la primer línea con dos puntos `:`.\n",
    "5. La siguientes líneas contienen las operaciones que realiza la función, en este caso es una sola, pero potencialmente podrían ser decenas o cientos de líneas.\n",
    "6. Por último tenemos otra palabra reservada `return` seguida del valor que devuelve la función, es decir del resultado de la función. Esta ultima línea es opcional ya que es posible definir funciones que no devuelvan valor alguno (ya veremos ejemplos).\n",
    "\n",
    "Es importante notar un detalle, muy particular de Python, todo el contenido de la función (lineas 2 y 3) está escrito usando una sangría de 4 espacios, la sangría es obligatoria y le indica a Python cual es el _cuerpo_ de la función, mientras que los 4 espacios es convención. Podrían ser 2, 3, 8, etc, lo importante es respetar la misma cantidad.\n",
    "\n",
    "Una vez definida una función se la puede _llamar_ usando su nombre y pasándole los argumentos necesarios."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.5"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "calcular_media(num)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Una detalle importante a notar es que el nombre de la variable que le pasamos a nuestra función no tiene nada que ver con el nombre del argumento de la función. Es decir nosotros le pasamos a la función un objeto llamado `num`, internamente `calcular_media` le asigna a ese objeto el alias `a`. Técnicamente decimos que `a` es una variable local de la función `calcular_media`, es decir `a` solo existe dentro de esta función, fuera de ella `a` podría no existir o ser una variable distinta."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2.6666666666666665, 6)"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "calcular_media([1, 3, 4]), a # dentro de la función `a` contiene una lista, fuera el valor 6"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Otra convención en Python es escribir las funciones incluyendo un `docstring`. Que no es más que un `string` que se escribe a partir de la segunda línea de la función y que Python ignora por completo al ejecutar la función. La información contenida en el `docstring` no es para Python, es para los humanos que lo usan! El `docstring` consiste en una explicación sobre las operaciones que realiza una función, qué valores espera la función como entrada y qué valores devuelve (si es que devuelve algo). Los docstring se escriben usando comillas triples `\"\"\"` esto permite que el docstring tenga varias lineas. El estilo exacto de los docstring varía, pero la mayoría de las funciones en Python tratan de mantener un mismo estilo para sus docstrings. Un ejemplo de docstring sería:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def calcular_media(a):\n",
    "    \"\"\"\n",
    "    Calcula la media partir de una lista.\n",
    "    \n",
    "    Parametros\n",
    "    ----------\n",
    "    a : lista\n",
    "        Contiene los valores a promediar\n",
    "    \n",
    "    Resultado\n",
    "    ----------\n",
    "    res : float\n",
    "        La media de los valores contenidos en `a`\n",
    "    \"\"\"\n",
    "    res = sum(a) / len(a)\n",
    "    return res"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Entonces, la forma general de un docstring sería:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "    \"\"\"\n",
    "    Descripción, ¿para qué sirve la función? ¿qué tarea realiza?\n",
    "\n",
    "    Parametros\n",
    "    ----------\n",
    "    nombre : tipo \n",
    "        descripción\n",
    "\n",
    "    Resultado\n",
    "    ----------\n",
    "    nombre : tipo\n",
    "        descripción\n",
    "    \"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El docstring no solo puede ser leído directamente del código, si no que puede ser usado por Python y por varias herramientas externas. Por ejemplo la función `help()` de Python ofrece ayuda sobre una función al usuario \"mostrando el docstring\". Por ejemplo, si quisieramos ver qué hace la función `len()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function len in module builtins:\n",
      "\n",
      "len(obj, /)\n",
      "    Return the number of items in a container.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(len)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Esto no solo sirve para funciones que ya vienen con Python, si no que el mismo mecanismo es usado para funciones definidas por los usuarios."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function calcular_media in module __main__:\n",
      "\n",
      "calcular_media(a)\n",
      "    Calcula la media partir de una lista.\n",
      "    \n",
      "    Parametros\n",
      "    ----------\n",
      "    a : lista\n",
      "        Contiene los valores a promediar\n",
      "    \n",
      "    Resultado\n",
      "    ----------\n",
      "    res : float\n",
      "        La media de los valores contenidos en `a`\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(calcular_media)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Jupyter (lo que estamos usando para mostrar este documento y ejecutar el código), también permite acceder al docstring usando `shift + TAB`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<function __main__.calcular_media>"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "calcular_media# seleccioná esta celda y presioná shift + tab"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dentro de Jupyter también se puede acceder a la ayuda escribiendo `?` o  `??` luego de la función y presionado `enter`.\n",
    "\n",
    "Todo muy bien hasta ahora, pero ¿Qué pasaría si inadvertidamente le pasáramos una lista vacía a nuestra función?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "ename": "ZeroDivisionError",
     "evalue": "division by zero",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mZeroDivisionError\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-33-2f8f5a12aa35>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mcalcular_media\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-28-bc55b6bf6449>\u001b[0m in \u001b[0;36mcalcular_media\u001b[0;34m(a)\u001b[0m\n\u001b[1;32m     13\u001b[0m         \u001b[0mLa\u001b[0m \u001b[0mmedia\u001b[0m \u001b[0mde\u001b[0m \u001b[0mlos\u001b[0m \u001b[0mvalores\u001b[0m \u001b[0mcontenidos\u001b[0m \u001b[0men\u001b[0m\u001b[0;31m \u001b[0m\u001b[0;31m`\u001b[0m\u001b[0ma\u001b[0m\u001b[0;31m`\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     14\u001b[0m     \"\"\"\n\u001b[0;32m---> 15\u001b[0;31m     \u001b[0mres\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msum\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m/\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     16\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0mres\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mZeroDivisionError\u001b[0m: division by zero"
     ]
    }
   ],
   "source": [
    "calcular_media([])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Obtenemos un error! Antes de seguir leyendo intentemos entender cual es la causa del error y en que parte del código se encuentra.\n",
    "\n",
    "<br>\n",
    "<hr>\n",
    "<br>\n",
    "Como se puede ver el problema se debe a que la división por 0 no está definida. Este es un tipo de error que no se debe a que metimos la pata al programar el cálculo de la media, se debe a una imposibilidad matemática. Es, si lo pensamos, un error esperado algo que es razonable que ocurra, en la jerga _pitónica_ decimos que es una _excepción_. Python permite lidiar con las excepciones de forma elegante (en vez de dejar que el programa falle horriblemente). Veamos primero el código y luego la explicación."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def calcular_media2(a):\n",
    "    \"\"\"\n",
    "    Calcula la media partir de una lista.\n",
    "    \n",
    "    Parametros\n",
    "    ----------\n",
    "    a : lista\n",
    "        lista que contiene los valores a promediar\n",
    "    \n",
    "    Resultado\n",
    "    ----------\n",
    "    res : float\n",
    "        La media de los valores contenidos en `a`\n",
    "        Devuelve una advertencia si `a` está vacía.\n",
    "    \"\"\"\n",
    "    try:\n",
    "        res = sum(a) / len(a)\n",
    "        return res\n",
    "    except ZeroDivisionError:\n",
    "        print('la lista está vacía, por favor use una lista con números')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "la lista está vacía, por favor use una lista con números\n"
     ]
    }
   ],
   "source": [
    "calcular_media2([])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ahora la función en vez de fallar devuelve un mensaje.\n",
    "La novedad es que usamos el bloque `try-except`. Lo que hace esto es intentar correr lo que está dentro de cuerpo de `try`, si llegara a ocurrir un error, que en este caso hemos especificado que sea del tipo `ZeroDivisionError`, entonces se ejecuta lo que sea que esté dentro del bloque `except` en este caso un mensaje, pero podría ser otra cualquier cosa. Si hubieramos escrito solo `except:` (sin especificar `ZeroDivisionError`) entonces el bloque `except` se ejecutaría sin importar el tipo de error, esto si bien es legal no se recomienda ya que puede llegar a ocultar _bugs_. Por ejemplo `sum()` (y también`len()`) devuelven un error si lo usáramos con un entero en vez de una lista."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'int' object is not iterable",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-36-b3516c918068>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mcalcular_media2\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-34-7619d75cfff2>\u001b[0m in \u001b[0;36mcalcular_media2\u001b[0;34m(a)\u001b[0m\n\u001b[1;32m     15\u001b[0m     \"\"\"\n\u001b[1;32m     16\u001b[0m     \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 17\u001b[0;31m         \u001b[0mres\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msum\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m/\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     18\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0mres\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     19\u001b[0m     \u001b[0;32mexcept\u001b[0m \u001b[0mZeroDivisionError\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mTypeError\u001b[0m: 'int' object is not iterable"
     ]
    }
   ],
   "source": [
    "calcular_media2(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Mediana\n",
    "\n",
    "La media es una buena descripción si los datos que estamos midiendo son más o menos similares, pero puede ofrecer una visión muy distorsionada si los datos no son muy similares entre si, por ejemplo como puede suceder con los ingresos, algunas personas apenas ganan unos pocos pesos mientras que otras acumulan millones por mes.\n",
    "\n",
    "La mediana es el número que separa un conjunto de datos en una mitad superior y otra inferior. La mediana es una medida más robusta que la media a valores extremos. Veamos un ejemplo para el conjunto $\\mathcal{D} = \\{1,2,3,4,5\\}$, la media y la mediana es igual a 3. Si ahora agregaramos a este conjunto un nuevo valor, por ejemplo 100. La media pasará a ser $\\eqsim 19,16$ mientras que la mediana apenas cambiará a 3.5 $\\left ( \\frac{3 + 4}{2} \\right )$.\n",
    "\n",
    "Para calcular la mediana necesitamos algunos conceptos nuevos. Una caracterísitca de las listas de Python es que es posible acceder a los elementos contenidos en ellas mediante índices. Los índices deben ser enteros, empiezan en 0 y terminan en `len(.)-1` y pueden ser negativos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lista = [5, 4, 3, 2, 1]\n",
    "lista[0]  # el cero-ésimo elemento de la lista"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lista[2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "ename": "IndexError",
     "evalue": "list index out of range",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-39-00214ecca91d>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mlista\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;31m# este índice no existe en este caso y Python nos lo indica con un error\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mIndexError\u001b[0m: list index out of range"
     ]
    }
   ],
   "source": [
    "lista[5] # este índice no existe en este caso y Python nos lo indica con un error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lista[-5]  # devuelve el último elemento, ¿Qué devolverá -2 y -6?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "No solo es posible acceder a elementos individuales de una lista, también se puede acceder a rebanadas (`slices`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[4, 3, 2, 1]"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lista[1:]  # del elemento 1 al final"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[4, 3, 2]"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lista[1:4]  # del elemento 1 al 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[5, 3, 1]"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lista[::2]  # del primer elemento al último \"de a 2\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5]"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lista[::-1]  # del primer elemento al último \"de a -1\", invierte el orden!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[5, 4, 3, 2, 1]"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lista[:]  # un caso trivial, del primer al último elemento (equivale a no usar un slice!)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ya estamos un poco más cerca de calcular la mediana, pero nos falta aprender lo que se conoce como control de flujo. Es común que al escribir un programa necesitemos ejecutar una acción de forma condicional, algo del estilo si pasa A entonces X y sino B entonces Y. Esto se consigue en Python con el bloque `if-else`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hola\n"
     ]
    }
   ],
   "source": [
    "if 2 > 1: # esto es cierto\n",
    "    print('hola')\n",
    "else:\n",
    "    print('chau')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si la condición a la derecha de `if` evalua como verdadero se ejecuta el cuerpo dentro de `if`, de lo contrario se ejecuta el bloque `else`. Veamos el siguiente ejemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "chau\n"
     ]
    }
   ],
   "source": [
    "if 1 > 2: # esto es falso\n",
    "    print('hola')\n",
    "else:\n",
    "    print('chau')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El bloque `else` es opcional"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hola\n"
     ]
    }
   ],
   "source": [
    "if True: # esto es siempre cierto\n",
    "    print('hola')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Es posible revisar más de una condición, en el siguiente ejemplo debido a que la expresión a la derecha de `if` evalua como falso se evalua la siguiente condición, que en este caso evalua como verdadera."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello\n"
     ]
    }
   ],
   "source": [
    "if 1 > 2: # esto es falso\n",
    "    print('hola')\n",
    "elif 2 > 1: # esto es cierto, solo se ejecuta si if evalua falso\n",
    "    print('hello')\n",
    "else:\n",
    "    calcula un índice\n",
    "    print('chau')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El bloque `if-else` es algo similar al bloque `try-except`, pero ese bloque está restringido a manejar posibles errores. En cambio el bloque `if-else` sirve para tomar decisiones que no tiene que ver con errores (o excepciones) si no con el funcionamiento _normal_ de un programa. \n",
    "\n",
    "Las listas vacías y otros contenedores vacíos (que veremos luego), el número 0, evalúan como `False`. Listas (u otros contenedores) con elementos, y números distintos de 0 evalúan como `True`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "if []:  # esto es falso\n",
    "    print('hola')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Todavía faltan un par de detalles, pero los vamos a ver directamente en la función. Es común al aprender una lenguaje encontrarse con código que contiene elementos desconocidos o \"frases\" que no sabíamos que eran posibles o legales."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def mediana(lista):\n",
    "    \"\"\"\n",
    "    ejercicio escribir docstring!\n",
    "    \"\"\"\n",
    "    lista_ordenada = sorted(lista)\n",
    "    lista_len = len(lista_ordenada)\n",
    "    idx = int((lista_len - 1) / 2)\n",
    "\n",
    "    if lista_len % 2:\n",
    "        return lista_ordenada[idx]\n",
    "    else:\n",
    "        return (lista_ordenada[idx] + lista_ordenada[idx + 1]) / 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Esta es una función bastante más compleja que `calcular_media()`. Veamos línea por línea qué es lo que hace.\n",
    "\n",
    "1. La primer línea (luego del docstring) ordena de menor a mayor los elementos dentro de \"lista\".\n",
    "2. La segunda computa la longitud de `lista`.\n",
    "3. La tercera calcula un índice, usamos `int` para asegurarnos que el resultado es un entero.\n",
    "4. Esta línea evalúa `True` solo si `lista_len` es impar ¿Podés darte cuenta por qué? (tip: probá ese bloque de código en una celda separada).\n",
    "5. Si `lista_len` es par entonces se ejecutará el bloque `else`. La razón de tener este bloque es que si la cantidad de elementos es par NO es posible obtener el valor \"del medio\", entonces la mediana la computamos como un promedio de los dos valores \"del medio\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mediana([1, 2, 3, 4, 5])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Además de la media y la mediana existen otras medidas de centralidad como la moda. La moda es simplemente el valor más frecuente en un conjunto de datos."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  Varianza\n",
    "\n",
    "Mide la dispersión de un conjunto de valores. Es cero para un conjunto de valores idénticos.\n",
    "\n",
    "$$V(\\mathbf{x}) = E[(\\mathbf{x} - \\mu)^2] = \\frac{1}{n} \\sum_{i=1}^n (\\mu - x_i)^2 \\tag{1}$$\n",
    "\n",
    "Donde $\\mu$ es la media de $\\mathbf{x}$,\n",
    "\n",
    "Al igual que pasa con la media, se suele distinguir entre la varianza de la población $\\sigma^2$ y la varianza de una muestra $s^2$. Pero a diferencia de la media se puede probar que la fórmula anterior para $s^2$ subestima el valor de $\\sigma^2$. Es posible obtener un mejor estimador con una ligera modificación de la ecuación 1, la cual consiste en dividir por $n-1$ en vez de $n$. En la práctica esta _corrección_ solo es importante para cuando se tienen _pocos_ datos, a medida que los datos aumentan no hay mucha diferencia entre usar una u otra fórmula. Esto es facil de ver intuitivamente, para $n=2$ la diferencia entre $n$ y $n-1$ es relativamente grande, mientras que para $n=100$ esta diferencia es mucho más pequeña.\n",
    "\n",
    "A partir de la definición de varianza, vemos que para calcularla debemos repetir la operación $(\\mu - x_i)^2$ para cada valor en $\\mathbf{x}$ es decir debemos _iterar_, esto es una operación muy común en programación. Una de las formas más comunes de iteración es mediante el bucle `for`, por ejemplo para iterar sobre todos los valores contenidos en la lista `num` hacemos:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "for i in num:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Una operación muy común es querer iterar sobre una lista de valores, modificarlos y guardarlos en otra lista, por ejemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'num' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-13-8dc712875699>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[0mnum_2\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[1;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mnum\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      3\u001b[0m     \u001b[0mnum_2\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mi\u001b[0m\u001b[1;33m**\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      4\u001b[0m     \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnum_2\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      5\u001b[0m \u001b[0mnum_2\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mNameError\u001b[0m: name 'num' is not defined"
     ]
    }
   ],
   "source": [
    "num_2 = []\n",
    "for i in num:\n",
    "    num_2.append(i**2)\n",
    "    #print(num_2)\n",
    "num_2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. En la primer línea definimos una lista vacía.\n",
    "2. Luego iteramos sobre `num`, en cada iteración `i` toma un valor distinto.\n",
    "3. Calculamos el cuadrado de `i` y _adjuntamos_ ese valor a la lista `num_2`.\n",
    "\n",
    "Es importante notar que _append_ agrega elementos _al final_ de la lista, por eso el cuadrado de 6 ( el último elemento de `num`) es el último elemento de `num_2`. Para ver _append_ en acción descomentá la linea 4 de la celda anterior.\n",
    "\n",
    "Ahora si ya estamos en condiciones de calcular la varianza."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def varianza(valores):\n",
    "    \"\"\"\n",
    "    ejercicio escribir docstring!\n",
    "    \"\"\"\n",
    "    media = calcular_media2(valores)                                                     \n",
    "    var = []\n",
    "    for i in valores:\n",
    "        var.append((media - i) ** 2)\n",
    "    return calcular_media2(var)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.623275"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "varianza([0, 1, 2.72, 3.14])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "¿Notaron que la función `varianza` usa la función `calcular_media2`? No hay ningún problema en que una función llame a otra función (incluso existen funciones que se llaman a si mismas!). Esto permite escribir funciones complejas a partir de otras funciones más simples.\n",
    "\n",
    "No solo es posible iterar sobre listas, se puede iterar sobre otros objetos, la única condición es que sean _iterables_. Otros objetos _iterables_ son las _cadenas_. Por ejemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "h\n",
      "o\n",
      "l\n",
      "a\n"
     ]
    }
   ],
   "source": [
    "for c in 'hola':\n",
    "    print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El siguiente patrón, donde iteramos a la largo de una lista de enteros es tan común en Python (y otros lenguajes) que existe varias funciones que facilitan esta tarea. Una de ellas es `range`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 4, 9, 16, 25, 36, 49, 64]"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d = []\n",
    "for i in [0, 1, 2, 3, 4, 5, 6, 7, 8]:\n",
    "    d.append(i ** 2)\n",
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`range` usa la sintaxis [start,stop,step] a fin de generar enteros desde `start`, hasta `stop` (sin incluirlo) y opcionalente de a `step` pasos (por defecto 1). `start` es también opcional en cuyo caso empezará en 0. Como pueden ver la sintaxis es similar a lo que ya vimos con la rebanadas de una lista. La diferencia es que las rebanadas operan sobre una lista existente y la función de `range` es la de generar un objeto que _contiene_ enteros. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 4, 9, 16, 25, 36, 49, 64]"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d = []\n",
    "for i in range(0, 9):\n",
    "    d.append(i ** 2)\n",
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En Python3 `range` es un objeto que contiene las reglas para devolver valores, pero no los valores en si. Esto es un truco que permite ocupar menos memoria. Intuitivamente se puede ver que se requiere menos memoria para especificar la regla, \"devuelva todos los enteros de 0 a 1 millón\", que para escribir un millón de enteros.\n",
    "\n",
    "En el siguiente ejemplo vemos una diferencia entre el objeto `range` y una lista generada a partir de convertir `range` usando el comando `list`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(range(0, 9), [0, 1, 2, 3, 4, 5, 6, 7, 8])"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "range(9), list(range(9))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como veníamos diciendo al trabajar con Python es común repetir una _frase_ como la siguiente:\n",
    "\n",
    "* Creamos una lista vacía.\n",
    "* Iteramos a largo de algún _iterable_ como una lista o un _rango_.\n",
    "* Guardamos valores en la lista originalmente vacía.\n",
    "\n",
    "Este patrón es tan común que Python ofrece una versión alternativa, la cual es considerada por la mayoría de _Pitonistas_ como más simple y clara, aunque al principio puede que no se vea como simple y clara :-(\n",
    "\n",
    "Esta versión alternativa se llama _list comprehension_, o comprensión por listas. Y luce de la siguiente forma:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 4, 9, 16, 25, 36, 49, 64]"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# d = [i ** 2 for i in range(9)]\n",
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En palabras podríamos leerla como, \"genere una lista tomando la variable `i` elevándola al cuadrado y repitiendo esto para todos los valores de `i` en el rango de 0 a 9\".\n",
    "\n",
    "Usando _list compreherions_ podemos calcular la varianza de la siguiente forma:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def varianza(valores):\n",
    "    \"\"\"\n",
    "    ejercicio escribir docstring!\n",
    "    \"\"\"\n",
    "    media = calcular_media2(valores)\n",
    "    var = [(media - i) ** 2 for i in valores]\n",
    "    return calcular_media2(var)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Desviación estándar\n",
    "\n",
    "La desviación estándar es la raíz cuadrada de la varianza, en muchos problemas teóricos resulta más fácil manipular varianzas que desviaciones estándar, pero en general resulta más simple interpretar las desviaciones estándar ya que las unidades son las mismas que las de los datos.\n",
    "\n",
    "$$\\sigma = \\sqrt{V(x)}$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Bibliotecas\n",
    "\n",
    "En los ejemplos anteriores hemos visto como calcular la media, mediana y la varianza. Vimos además que es posible _encapsular_ código dentro de funciones y así reutilizarlo. El principal motivo de estos ejemplos fue motivar el aprendizaje de Python. En la práctica el cálculo de las funciones como la media o la varianza son tan comunes que resulta muy conveniente poder acceder a estas funciones sin necesidad de que debamos escribirlas nosotros. Es por esto que en Python (y otros lenguajes) existen las _bibliotecas_, que permiten extender el lenguaje. En el fondo estás bibliotecas (llamadas también _librerías_, por una transliteración del ingles _library_) no son otra cosa que un conjunto de funciones del estilo que aprendimos a escribir en este capítulo. En general las bibliotecas contienen funciones optimizadas, es decir funciones que corren rápido o que reducen la posibilidad de errores numéricos. Por lo que la ganancia al usarlas no es solo que nos ahorran tiempo si no que en general nos ahorran dolores de cabeza!\n",
    "\n",
    "Python posee un extenso _ecosistema_ de bibliotecas, muchas de ellas específicas para hacer ciencia. Algunas de esas bibliotecas más usadas son:\n",
    "\n",
    "\n",
    "* [Numpy:](http://numpy.scipy.org)  Cálculo numerico y algebra lineal\n",
    "* [Scipy:](http://www.scipy.org) -  Funciones comunmente usadas en ciencias\n",
    "* [Matplotlib:](http://www.matplotlib.org) - Gráficas científicas\n",
    "* [Seaborn:](http://web.stanford.edu/~mwaskom/software/seaborn/) - Gráficas cientificas _atractivas_.\n",
    "* [Jupyter:](http://jupyter.org/) - Computación interactiva\n",
    "* [Pandas:](http://pandas.pydata.org/) - Procesamiento de datos\n",
    "* [Scikit-learn:](http://scikit-learn.org/) - Machine Learning \n",
    "* [Statsmodels:](http://statsmodels.sourceforge.net/) Estadística _\"clásica\"_\n",
    "* [PyMC3:](http://pymc-devs.github.io/pymc3/) - Estadística Bayesiana\n",
    "* [SymPy](http://www.sympy.org/en/index.html) - Matemática simbólica\n",
    "* [Sage](http://sagemath.org/) - Es un entorno matemática basado en Python y varias de las bibliotecas arriba mencionadas\n",
    "* _agregá tu paquete favorito acá_\n",
    "\n",
    "Incluso algunas bibliotecas se construyen sobre otras bibliotecas. En el siguiente esquema se ve parte del ecosistema de Python ordenado (radialmente). Donde un nivel se apoya sobre los inferiores como en un cebolla.\n",
    "\n",
    "<a href=\"https://www.youtube.com/watch?v=5GlNDD7qbP4\">\n",
    "<img src='imagenes/Python_Stack.png' width=500 >\n",
    "</a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Además de estas bibliotecas _externas_ Python se distribuye con algunas bibliotecas _estándar_, por ejemplo `math` tiene varias funciones matemáticas. Para poder usarla necesitamos importarla de la siguiente forma."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import math"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ahora que la importamos podemos usarla por ejemplo para calcular un logaritmo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.302585092994046"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.log(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Qué otras funciones están disponibles dentro de `math`? Una forma de averiguarlo es usando la ayuda que nos ofrece jupyter. Recordá que basta escribir `math.` seguido de `Tab` para que Jupyter nos haga recomendaciones!\n",
    "\n",
    "Existen varias formas de importar modulos en Python, una alternativa a lo ya visto es importar una función específica, por ejemplo `sqrt`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from math import sqrt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.0"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sqrt(4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "También podemos importar una función pero cambiandole el nombre"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from math import sqrt as raiz"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.0"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "raiz(4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Para seguir leyendo\n",
    "\n",
    "Hasta este momento hemos visto algunos de los elementos básicos de Python. Python es un lenguaje muy rico y expresivo que cuenta con muchas otras características útiles que hemos omitido y que son necesarias para lograr un manejo fluido de este lenguaje. Lo que hemos visto hasta ahora son los elementos más importantes para el resto de este curso y seguiremos practicando Python en resto del curso. Recomiendo enfaticamente complementar este capítulo con material extra:\n",
    "\n",
    "* [Breve introducción a Python científico](https://github.com/aloctavodia/Intro_Python)\n",
    "* [Think Python](http://greenteapress.com/wp/think-python/) Muy buen libro introducctorio de Python."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ejercicios\n",
    "\n",
    "1. comparar la media y mediana para varios conjunto de datos usando las funciones lalala\n",
    "2. escribir una función para calcular la moda de un conjunto de valores discretos. ¿Cuán facil sería generalizar esa función para valores continuos?\n",
    "3. Modificar la función que computa la varianza agregando un nuevo argumento, llamado \"ddof\" (delta degree of freedom) de forma tal que cuando ddof=1 la función use $n-1$ y cuando ddof=0 use $n$.\n",
    "4. Escribir una función para calcular la media truncada. Es decir luego de haber eliminado una cantidad determinada de valores a ambos extremos del conjunto de datos, por ejemplo el 5% de los datos.\n",
    "5. Dentro de Jupyter se puede acceder a la ayuda escribiendo `?` o  `??`.¿Cual es la diferencia entre usar una u otra forma?"
   ]
  },
  {
   "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.6.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}