03_Manipulación_de_datos_y_Pandas.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "import numpy as np\n",
    "import pandas as pd  # asi se suele importar Pandas\n",
    "palette = 'colorblind'\n",
    "sns.set_palette(palette); sns.set_color_codes(palette)  # Fija los nombres cortos para los colores según la paleta de seaborn"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Esta notebook es una traducción y adaptación de [notebooks](https://github.com/fonnesbeck/Bios8366/tree/master/notebooks) creadas por Chris Fonnesbeck y de notebooks del libro [Python Data Science Handbook](https://github.com/jakevdp/PythonDataScienceHandbook) de Jake Vanderplas."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Manipulación de datos y Pandas\n",
    "\n",
    "**Pandas** es un paquete que Python que provee estructuras de datos rápidas, flexibles y expresivas diseñadas para trabajar con _rotulados_ y/o _relacionales_. Conceptualmente se pueden pensar como _arrays_ de NumPy donde las filas y colummnas están rótuladas. O de forma similar como una _planilla de cálculo_ bajo Python.\n",
    "\n",
    "Asi como NumPy es una muy buena herramienta para trabajar con números, vectores, algebra lineal, etc. Pandas es adecuado para trabajar con:\n",
    "\n",
    "* Datos tabulares y heterogeneos (flotantes, string, enteros, etc)\n",
    "* Series temporales\n",
    "* Los mismos datos que se pueden manipular con _arreglos_ de NumPy!\n",
    "\n",
    "Key features:\n",
    "    \n",
    "- Easy handling of **missing data**\n",
    "- **Size mutability**: columns can be inserted and deleted from DataFrame and higher dimensional objects\n",
    "- Automatic and explicit **data alignment**: objects can be explicitly aligned to a set of labels, or the data can be aligned automatically\n",
    "- Powerful, flexible **group by functionality** to perform split-apply-combine operations on data sets\n",
    "- Intelligent label-based **slicing, fancy indexing, and subsetting** of large data sets\n",
    "- Intuitive **merging and joining** data sets\n",
    "- Flexible **reshaping and pivoting** of data sets\n",
    "- **Hierarchical labeling** of axes\n",
    "- Robust **IO tools** for loading data from flat files, Excel files, databases, and HDF5\n",
    "- **Time series functionality**: date range generation and frequency conversion, moving window statistics, moving window linear regressions, date shifting and lagging, etc."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Por que es importante tener una herramienta como Pandas?\n",
    "\n",
    "<img src=\"imagenes/analisis.jpeg\"  width=300>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pandas introduce fundamentalmente 3 nuevas estructuras de datos. La `Series` el `DataFrame`, y el `Index`. Empezemos por la primera de estas."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Series\n",
    "\n",
    "Una _Series_ de Pandas es un conjunto unidimensional de datos (similar a un _array_) acompañados de un índice que \"rotula\" a cada elemento del vector. Puede ser creada a partir de un array o tupla o lista."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0     632\n",
       "1    1638\n",
       "2     569\n",
       "3     115\n",
       "dtype: int64"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "conteo = pd.Series([632, 1638, 569, 115])\n",
    "conteo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La primer columna es el índice y la segunda nuestros datos. Como omitimos indicar un índice Pandas asignó automáticamente una secuencia de enteros (empezando por 0). \n",
    "\n",
    "A partir de una serie es posible obtener solo el _array_ de NumPy \"contenido\" en ella."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 632, 1638,  569,  115])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "conteo.values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como también es posible obtener solo el índice."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "RangeIndex(start=0, stop=4, step=1)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "conteo.index"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Es importante notar que los arreglos de NumPy también tienen índices, solo que estos están implícitios y siemrpe son enteros comenzando desde el 0. En cambio los índices en Pandas son explícitos. Podemos asignar rotulos que tengan sentido según nuestros datos. Si nuestros datos representan la cantidad de diversas bacterias en una muestra, podríamos tener algo como:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Firmicutes         632\n",
       "Proteobacteria    1638\n",
       "Actinobacteria     569\n",
       "Bacteroidetes      115\n",
       "dtype: int64"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bacteria = pd.Series([632, 1638, 569, 115], \n",
    "    index=['Firmicutes', 'Proteobacteria', 'Actinobacteria', 'Bacteroidetes'])\n",
    "\n",
    "bacteria"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ahora que tenemos  rótulos por un lado y datos por el otro da la impresión que una serie se podría pensar también como una especie de diccionario! De hecho podemos usar los rótulos para referirnos directamente a valores en la serie."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "569"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bacteria['Actinobacteria']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O usando una sintaxis ligeramente más simple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "569"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bacteria.Actinobacteria"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A diferencia de los diccionarios es posible hacer `slicing`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Proteobacteria    1638\n",
       "Actinobacteria     569\n",
       "Bacteroidetes      115\n",
       "dtype: int64"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bacteria['Proteobacteria':]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Al igual que con los arreglos de NumPy podemos usar booleanos para indexar una serie. Si quisieramos el conteo de  bacterias para todas aquellas cuyos nombres terminan en \"bacteria\" podríamos hacer:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Proteobacteria    1638\n",
       "Actinobacteria     569\n",
       "dtype: int64"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bacteria[[name.endswith('bacteria') for name in bacteria.index]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "U operaciones como:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Proteobacteria    1638\n",
       "dtype: int64"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bacteria[bacteria>1000]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "También es posible hacer uso del índice _implicito_ (como en listas y arreglos)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1638"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bacteria[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can give both the array of values and the index meaningful labels themselves:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "phylum\n",
       "Firmicutes         632\n",
       "Proteobacteria    1638\n",
       "Actinobacteria     569\n",
       "Bacteroidetes      115\n",
       "Name: counts, dtype: int64"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bacteria.name = 'counts'\n",
    "bacteria.index.name = 'phylum'\n",
    "bacteria"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Es posible operar con los valores de una serie manteniendo los rótulos sin modificar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "phylum\n",
       "Firmicutes        6.448889\n",
       "Proteobacteria    7.401231\n",
       "Actinobacteria    6.343880\n",
       "Bacteroidetes     4.744932\n",
       "Name: counts, dtype: float64"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.log(bacteria)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como ya dijimos es posible pensar en una `Series` como si fuera una especie de diccionario, incluso podemos crear series a partir de diccionarios!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Actinobacteria     569\n",
       "Bacteroidetes      115\n",
       "Firmicutes         632\n",
       "Proteobacteria    1638\n",
       "dtype: int64"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bacteria_dict = {'Firmicutes': 632, 'Proteobacteria': 1638, 'Actinobacteria': 569, 'Bacteroidetes': 115}\n",
    "pd.Series(bacteria_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si observan con atención verán que Pandas ordenó alfabeticamente los indices en la `Series` (junto con sus valores asociados).\n",
    "\n",
    "Si queremos añgun orden en particular podemos especificar los índices. Incluso podemos pasar rotulos para valores que no existen. En ese caso Pandas interpretará que tenemos datos faltantes (_missing data_) y lo indicará usando un tipo especial de _float_ `NaN` (not a number)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Cyanobacteria        NaN\n",
       "Firmicutes         632.0\n",
       "Proteobacteria    1638.0\n",
       "Actinobacteria     569.0\n",
       "dtype: float64"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bacteria2 = pd.Series(bacteria_dict, index=['Cyanobacteria','Firmicutes','Proteobacteria','Actinobacteria'])\n",
    "bacteria2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Es posible preguntarle a Pandas si tenemos valores faltantes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Cyanobacteria      True\n",
       "Firmicutes        False\n",
       "Proteobacteria    False\n",
       "Actinobacteria    False\n",
       "dtype: bool"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bacteria2.isnull()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Los índices no son solo una conveniencia para manipular datos haciendo referencia a nombres que nos puede resultar más familiares o convenientes (comparado con recordar la posición de los datos). Los índices son usados para **alienar datos** al operar con más de una serie, por ej podríamos queres obtner el total de bacterias en dos conjuntos de datos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "phylum\n",
       "Firmicutes         632\n",
       "Proteobacteria    1638\n",
       "Actinobacteria     569\n",
       "Bacteroidetes      115\n",
       "Name: counts, dtype: int64"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bacteria"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Actinobacteria    1138.0\n",
       "Bacteroidetes        NaN\n",
       "Cyanobacteria        NaN\n",
       "Firmicutes        1264.0\n",
       "Proteobacteria    3276.0\n",
       "dtype: float64"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bacteria + bacteria2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como verán Pandas sumó solo los valores para  los cuales los índices de ambas `Series` coinciden, propagando además los valores faltantes (`NaN`). \n",
    "\n",
    "¿Cómo se compara esto con sumar dos arreglos de NumPy de distinta longitud?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## DataFrame\n",
    "\n",
    "Al analizar datos es común que tengamos que trabajar con datos multivariados. Es decir con más de uan variable. Para esos casos sería útil tener algo como una `Series` donde para cada índice tengamos más de una columna de valores. Ese objeto se llama `DataFrame`.\n",
    "\n",
    "Un `DataFrame` es una estructura de datos tabular que se puede pensar como una colección de `Series` (que comparten un mismo índice). También es posible pensar un `DataFrame` como una generalización de un arreglo de NumPy o de una diccionario. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>conteo</th>\n",
       "      <th>paciente</th>\n",
       "      <th>phylum</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>632</td>\n",
       "      <td>1</td>\n",
       "      <td>Firmicutes</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1638</td>\n",
       "      <td>1</td>\n",
       "      <td>Proteobacteria</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>569</td>\n",
       "      <td>1</td>\n",
       "      <td>Actinobacteria</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>115</td>\n",
       "      <td>1</td>\n",
       "      <td>Bacteroidetes</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>433</td>\n",
       "      <td>2</td>\n",
       "      <td>Firmicutes</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>1130</td>\n",
       "      <td>2</td>\n",
       "      <td>Proteobacteria</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>754</td>\n",
       "      <td>2</td>\n",
       "      <td>Actinobacteria</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>555</td>\n",
       "      <td>2</td>\n",
       "      <td>Bacteroidetes</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   conteo  paciente          phylum\n",
       "0     632         1      Firmicutes\n",
       "1    1638         1  Proteobacteria\n",
       "2     569         1  Actinobacteria\n",
       "3     115         1   Bacteroidetes\n",
       "4     433         2      Firmicutes\n",
       "5    1130         2  Proteobacteria\n",
       "6     754         2  Actinobacteria\n",
       "7     555         2   Bacteroidetes"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "datos = pd.DataFrame({'conteo':[632, 1638, 569, 115, 433, 1130, 754, 555],\n",
    "                     'paciente':[1, 1, 1, 1, 2, 2, 2, 2],\n",
    "                     'phylum':['Firmicutes', 'Proteobacteria', 'Actinobacteria', \n",
    "    'Bacteroidetes', 'Firmicutes', 'Proteobacteria', 'Actinobacteria', 'Bacteroidetes']})\n",
    "datos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lo primero que notamos es que `Jupyter` le pone un poco de estilo al `DataFrame`, y lo muestra como una tabla con algunas mejoras estéticas (comaprado con un montón de números como se ven arreglos, listas y series).\n",
    "\n",
    "También podemos ver que contrario a un arreglo de NumPy en un `DataFrame` podemos tener datos de distinto tipo (enteros y _strings_ en este caso). Además se ve que las columnas están ordenadas alfabeticamente, podemos cambiar el orden indexando el `DataFrame` en el orden preferido."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>paciente</th>\n",
       "      <th>phylum</th>\n",
       "      <th>conteo</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>Firmicutes</td>\n",
       "      <td>632</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>Proteobacteria</td>\n",
       "      <td>1638</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1</td>\n",
       "      <td>Actinobacteria</td>\n",
       "      <td>569</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1</td>\n",
       "      <td>Bacteroidetes</td>\n",
       "      <td>115</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>2</td>\n",
       "      <td>Firmicutes</td>\n",
       "      <td>433</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>2</td>\n",
       "      <td>Proteobacteria</td>\n",
       "      <td>1130</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>2</td>\n",
       "      <td>Actinobacteria</td>\n",
       "      <td>754</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>2</td>\n",
       "      <td>Bacteroidetes</td>\n",
       "      <td>555</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   paciente          phylum  conteo\n",
       "0         1      Firmicutes     632\n",
       "1         1  Proteobacteria    1638\n",
       "2         1  Actinobacteria     569\n",
       "3         1   Bacteroidetes     115\n",
       "4         2      Firmicutes     433\n",
       "5         2  Proteobacteria    1130\n",
       "6         2  Actinobacteria     754\n",
       "7         2   Bacteroidetes     555"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "datos[['paciente', 'phylum', 'conteo']]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Los `DataFrame` tienen dos `index`, el mismo que ya vimos para las series que se corresponden con las filas y uno nuevo que se corresponde con las columnas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Index(['conteo', 'paciente', 'phylum'], dtype='object')"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "datos.columns"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Es posible acceder a los valores de las columnas como con un diccionario"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0     632\n",
       "1    1638\n",
       "2     569\n",
       "3     115\n",
       "4     433\n",
       "5    1130\n",
       "6     754\n",
       "7     555\n",
       "Name: conteo, dtype: int64"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "datos['conteo']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "o por atributo (un atributo es el nombre que se le da a un dato o propiedad en programación orientada a objetos)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0     632\n",
       "1    1638\n",
       "2     569\n",
       "3     115\n",
       "4     433\n",
       "5    1130\n",
       "6     754\n",
       "7     555\n",
       "Name: conteo, dtype: int64"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "datos.conteo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Una posible fuente  de confusión es que la sintaxis que acabamos de ver devuelve filas en una `Series`, pero columnas en un `DataFrame`. Si queremos acceder a las filas de un `DataFrame` podemos hacerlo usando el atributo `ix`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "conteo                115\n",
       "paciente                1\n",
       "phylum      Bacteroidetes\n",
       "Name: 3, dtype: object"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "datos.ix[3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "¿Que pasa si intentamos acceder a una fila usando la sintaxis `datos[3]`?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La serie que se obtieen al indexar un `DataFrame` es una _vista_ (_view_) del `DataFrame` y NO una copia. Por lo que hay que tener cuidado al manipularla, por ello Pandas nos devuelve una advertencia."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0     632\n",
       "1    1638\n",
       "2     569\n",
       "3     115\n",
       "4     433\n",
       "5    1130\n",
       "6     754\n",
       "7     555\n",
       "Name: conteo, dtype: int64"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cont = datos.conteo\n",
    "cont"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/osvaldo/anaconda3/lib/python3.5/site-packages/ipykernel_launcher.py:1: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\n",
      "\n",
      "See the caveats in the documentation: http://pandas.pydata.org/pandas-docs/stable/indexing.html#indexing-view-versus-copy\n",
      "  \"\"\"Entry point for launching an IPython kernel.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0     632\n",
       "1    1638\n",
       "2     569\n",
       "3     115\n",
       "4     433\n",
       "5       0\n",
       "6     754\n",
       "7     555\n",
       "Name: conteo, dtype: int64"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cont[5] = 0\n",
    "cont"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>conteo</th>\n",
       "      <th>paciente</th>\n",
       "      <th>phylum</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>632</td>\n",
       "      <td>1</td>\n",
       "      <td>Firmicutes</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1638</td>\n",
       "      <td>1</td>\n",
       "      <td>Proteobacteria</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>569</td>\n",
       "      <td>1</td>\n",
       "      <td>Actinobacteria</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>115</td>\n",
       "      <td>1</td>\n",
       "      <td>Bacteroidetes</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>433</td>\n",
       "      <td>2</td>\n",
       "      <td>Firmicutes</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>0</td>\n",
       "      <td>2</td>\n",
       "      <td>Proteobacteria</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>754</td>\n",
       "      <td>2</td>\n",
       "      <td>Actinobacteria</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>555</td>\n",
       "      <td>2</td>\n",
       "      <td>Bacteroidetes</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   conteo  paciente          phylum\n",
       "0     632         1      Firmicutes\n",
       "1    1638         1  Proteobacteria\n",
       "2     569         1  Actinobacteria\n",
       "3     115         1   Bacteroidetes\n",
       "4     433         2      Firmicutes\n",
       "5       0         2  Proteobacteria\n",
       "6     754         2  Actinobacteria\n",
       "7     555         2   Bacteroidetes"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "datos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si queremos moficiar una `Series` que proviene de un `DataFrame` puede ser buena idea hacer una copia primero."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>conteo</th>\n",
       "      <th>paciente</th>\n",
       "      <th>phylum</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>632</td>\n",
       "      <td>1</td>\n",
       "      <td>Firmicutes</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1638</td>\n",
       "      <td>1</td>\n",
       "      <td>Proteobacteria</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>569</td>\n",
       "      <td>1</td>\n",
       "      <td>Actinobacteria</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>115</td>\n",
       "      <td>1</td>\n",
       "      <td>Bacteroidetes</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>433</td>\n",
       "      <td>2</td>\n",
       "      <td>Firmicutes</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>0</td>\n",
       "      <td>2</td>\n",
       "      <td>Proteobacteria</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>754</td>\n",
       "      <td>2</td>\n",
       "      <td>Actinobacteria</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>555</td>\n",
       "      <td>2</td>\n",
       "      <td>Bacteroidetes</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   conteo  paciente          phylum\n",
       "0     632         1      Firmicutes\n",
       "1    1638         1  Proteobacteria\n",
       "2     569         1  Actinobacteria\n",
       "3     115         1   Bacteroidetes\n",
       "4     433         2      Firmicutes\n",
       "5       0         2  Proteobacteria\n",
       "6     754         2  Actinobacteria\n",
       "7     555         2   Bacteroidetes"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cont = datos.conteo.copy()\n",
    "cont[5] = 1000\n",
    "datos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Es posible crear columnas usando asignaciones"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>conteo</th>\n",
       "      <th>paciente</th>\n",
       "      <th>phylum</th>\n",
       "      <th>year</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>632</td>\n",
       "      <td>1</td>\n",
       "      <td>Firmicutes</td>\n",
       "      <td>2013</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1638</td>\n",
       "      <td>1</td>\n",
       "      <td>Proteobacteria</td>\n",
       "      <td>2013</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>569</td>\n",
       "      <td>1</td>\n",
       "      <td>Actinobacteria</td>\n",
       "      <td>2013</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>115</td>\n",
       "      <td>1</td>\n",
       "      <td>Bacteroidetes</td>\n",
       "      <td>2013</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>433</td>\n",
       "      <td>2</td>\n",
       "      <td>Firmicutes</td>\n",
       "      <td>2013</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>0</td>\n",
       "      <td>2</td>\n",
       "      <td>Proteobacteria</td>\n",
       "      <td>2013</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>754</td>\n",
       "      <td>2</td>\n",
       "      <td>Actinobacteria</td>\n",
       "      <td>2013</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>555</td>\n",
       "      <td>2</td>\n",
       "      <td>Bacteroidetes</td>\n",
       "      <td>2013</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   conteo  paciente          phylum  year\n",
       "0     632         1      Firmicutes  2013\n",
       "1    1638         1  Proteobacteria  2013\n",
       "2     569         1  Actinobacteria  2013\n",
       "3     115         1   Bacteroidetes  2013\n",
       "4     433         2      Firmicutes  2013\n",
       "5       0         2  Proteobacteria  2013\n",
       "6     754         2  Actinobacteria  2013\n",
       "7     555         2   Bacteroidetes  2013"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "datos['year'] = 2013\n",
    "datos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pero para hacer esto no es posible usar la sintaxiis de  atributo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "datos.tratamiento = 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Aunque esto crea el atributo y le asgina el valor 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "datos.tratamiento"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Este cambio no se ve reflejado en el `DataFrame`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>conteo</th>\n",
       "      <th>paciente</th>\n",
       "      <th>phylum</th>\n",
       "      <th>year</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>632</td>\n",
       "      <td>1</td>\n",
       "      <td>Firmicutes</td>\n",
       "      <td>2013</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1638</td>\n",
       "      <td>1</td>\n",
       "      <td>Proteobacteria</td>\n",
       "      <td>2013</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>569</td>\n",
       "      <td>1</td>\n",
       "      <td>Actinobacteria</td>\n",
       "      <td>2013</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>115</td>\n",
       "      <td>1</td>\n",
       "      <td>Bacteroidetes</td>\n",
       "      <td>2013</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>433</td>\n",
       "      <td>2</td>\n",
       "      <td>Firmicutes</td>\n",
       "      <td>2013</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>0</td>\n",
       "      <td>2</td>\n",
       "      <td>Proteobacteria</td>\n",
       "      <td>2013</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>754</td>\n",
       "      <td>2</td>\n",
       "      <td>Actinobacteria</td>\n",
       "      <td>2013</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>555</td>\n",
       "      <td>2</td>\n",
       "      <td>Bacteroidetes</td>\n",
       "      <td>2013</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   conteo  paciente          phylum  year\n",
       "0     632         1      Firmicutes  2013\n",
       "1    1638         1  Proteobacteria  2013\n",
       "2     569         1  Actinobacteria  2013\n",
       "3     115         1   Bacteroidetes  2013\n",
       "4     433         2      Firmicutes  2013\n",
       "5       0         2  Proteobacteria  2013\n",
       "6     754         2  Actinobacteria  2013\n",
       "7     555         2   Bacteroidetes  2013"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "datos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos agregar una `Series` como una nueva columna en un `DataFrame`, el resultado dependerá de los índices de ambos objetos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    0\n",
       "1    0\n",
       "2    0\n",
       "3    0\n",
       "4    1\n",
       "5    1\n",
       "dtype: int64"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tratamiento = pd.Series([0]*4 + [1]*2)\n",
    "tratamiento"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>conteo</th>\n",
       "      <th>paciente</th>\n",
       "      <th>phylum</th>\n",
       "      <th>year</th>\n",
       "      <th>tratamiento</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>632</td>\n",
       "      <td>1</td>\n",
       "      <td>Firmicutes</td>\n",
       "      <td>2013</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1638</td>\n",
       "      <td>1</td>\n",
       "      <td>Proteobacteria</td>\n",
       "      <td>2013</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>569</td>\n",
       "      <td>1</td>\n",
       "      <td>Actinobacteria</td>\n",
       "      <td>2013</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>115</td>\n",
       "      <td>1</td>\n",
       "      <td>Bacteroidetes</td>\n",
       "      <td>2013</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>433</td>\n",
       "      <td>2</td>\n",
       "      <td>Firmicutes</td>\n",
       "      <td>2013</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>0</td>\n",
       "      <td>2</td>\n",
       "      <td>Proteobacteria</td>\n",
       "      <td>2013</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>754</td>\n",
       "      <td>2</td>\n",
       "      <td>Actinobacteria</td>\n",
       "      <td>2013</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>555</td>\n",
       "      <td>2</td>\n",
       "      <td>Bacteroidetes</td>\n",
       "      <td>2013</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   conteo  paciente          phylum  year  tratamiento\n",
       "0     632         1      Firmicutes  2013          0.0\n",
       "1    1638         1  Proteobacteria  2013          0.0\n",
       "2     569         1  Actinobacteria  2013          0.0\n",
       "3     115         1   Bacteroidetes  2013          0.0\n",
       "4     433         2      Firmicutes  2013          1.0\n",
       "5       0         2  Proteobacteria  2013          1.0\n",
       "6     754         2  Actinobacteria  2013          NaN\n",
       "7     555         2   Bacteroidetes  2013          NaN"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "datos['tratamiento'] = tratamiento\n",
    "datos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "¿Que pasa si intentamos agregar una nueva columna que no sea una serie y cuyo longitud no coincida con la del `DataFrame`?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>conteo</th>\n",
       "      <th>paciente</th>\n",
       "      <th>phylum</th>\n",
       "      <th>year</th>\n",
       "      <th>tratamiento</th>\n",
       "      <th>mes</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>632</td>\n",
       "      <td>1</td>\n",
       "      <td>Firmicutes</td>\n",
       "      <td>2013</td>\n",
       "      <td>0.0</td>\n",
       "      <td>enero</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1638</td>\n",
       "      <td>1</td>\n",
       "      <td>Proteobacteria</td>\n",
       "      <td>2013</td>\n",
       "      <td>0.0</td>\n",
       "      <td>enero</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>569</td>\n",
       "      <td>1</td>\n",
       "      <td>Actinobacteria</td>\n",
       "      <td>2013</td>\n",
       "      <td>0.0</td>\n",
       "      <td>enero</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>115</td>\n",
       "      <td>1</td>\n",
       "      <td>Bacteroidetes</td>\n",
       "      <td>2013</td>\n",
       "      <td>0.0</td>\n",
       "      <td>enero</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>433</td>\n",
       "      <td>2</td>\n",
       "      <td>Firmicutes</td>\n",
       "      <td>2013</td>\n",
       "      <td>1.0</td>\n",
       "      <td>enero</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>0</td>\n",
       "      <td>2</td>\n",
       "      <td>Proteobacteria</td>\n",
       "      <td>2013</td>\n",
       "      <td>1.0</td>\n",
       "      <td>enero</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>754</td>\n",
       "      <td>2</td>\n",
       "      <td>Actinobacteria</td>\n",
       "      <td>2013</td>\n",
       "      <td>NaN</td>\n",
       "      <td>enero</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>555</td>\n",
       "      <td>2</td>\n",
       "      <td>Bacteroidetes</td>\n",
       "      <td>2013</td>\n",
       "      <td>NaN</td>\n",
       "      <td>enero</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   conteo  paciente          phylum  year  tratamiento    mes\n",
       "0     632         1      Firmicutes  2013          0.0  enero\n",
       "1    1638         1  Proteobacteria  2013          0.0  enero\n",
       "2     569         1  Actinobacteria  2013          0.0  enero\n",
       "3     115         1   Bacteroidetes  2013          0.0  enero\n",
       "4     433         2      Firmicutes  2013          1.0  enero\n",
       "5       0         2  Proteobacteria  2013          1.0  enero\n",
       "6     754         2  Actinobacteria  2013          NaN  enero\n",
       "7     555         2   Bacteroidetes  2013          NaN  enero"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "datos['mes'] = ['enero'] * len(datos)\n",
    "datos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos usar `del` para eliminar columnas de la misma forma que en diccionarios."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>conteo</th>\n",
       "      <th>paciente</th>\n",
       "      <th>phylum</th>\n",
       "      <th>year</th>\n",
       "      <th>tratamiento</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>632</td>\n",
       "      <td>1</td>\n",
       "      <td>Firmicutes</td>\n",
       "      <td>2013</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1638</td>\n",
       "      <td>1</td>\n",
       "      <td>Proteobacteria</td>\n",
       "      <td>2013</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>569</td>\n",
       "      <td>1</td>\n",
       "      <td>Actinobacteria</td>\n",
       "      <td>2013</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>115</td>\n",
       "      <td>1</td>\n",
       "      <td>Bacteroidetes</td>\n",
       "      <td>2013</td>\n",
       "      <td>0.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>433</td>\n",
       "      <td>2</td>\n",
       "      <td>Firmicutes</td>\n",
       "      <td>2013</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>0</td>\n",
       "      <td>2</td>\n",
       "      <td>Proteobacteria</td>\n",
       "      <td>2013</td>\n",
       "      <td>1.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>754</td>\n",
       "      <td>2</td>\n",
       "      <td>Actinobacteria</td>\n",
       "      <td>2013</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>555</td>\n",
       "      <td>2</td>\n",
       "      <td>Bacteroidetes</td>\n",
       "      <td>2013</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   conteo  paciente          phylum  year  tratamiento\n",
       "0     632         1      Firmicutes  2013          0.0\n",
       "1    1638         1  Proteobacteria  2013          0.0\n",
       "2     569         1  Actinobacteria  2013          0.0\n",
       "3     115         1   Bacteroidetes  2013          0.0\n",
       "4     433         2      Firmicutes  2013          1.0\n",
       "5       0         2  Proteobacteria  2013          1.0\n",
       "6     754         2  Actinobacteria  2013          NaN\n",
       "7     555         2   Bacteroidetes  2013          NaN"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "del datos['mes']\n",
    "datos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Es posible _extaer_ los datos de un `DataFrame` en forma de arreglo de NumPy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[632, 1, 'Firmicutes', 2013, 0.0],\n",
       "       [1638, 1, 'Proteobacteria', 2013, 0.0],\n",
       "       [569, 1, 'Actinobacteria', 2013, 0.0],\n",
       "       [115, 1, 'Bacteroidetes', 2013, 0.0],\n",
       "       [433, 2, 'Firmicutes', 2013, 1.0],\n",
       "       [0, 2, 'Proteobacteria', 2013, 1.0],\n",
       "       [754, 2, 'Actinobacteria', 2013, nan],\n",
       "       [555, 2, 'Bacteroidetes', 2013, nan]], dtype=object)"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "datos.values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Fijense que el `dtype` del arreglo es `object`. Esto se debe a la mezcla de enteros _strings_ y flotantes (`Nan`). El `dtype` es elegido por Pandas automaticamente de forma tal de acomodar todos los tipos de valores presentes en el `DataFrame`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Index\n",
    "\n",
    "La última estructura de datos que nos queda ver es `Index`, la cual en realidad la venimos usando desde el principio de este capítulo. Solo que ahora hablaremos de ella de forma un poco más explícita."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "RangeIndex(start=0, stop=8, step=1)"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "datos.index"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Los `Index` son inmutables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#datos.index[0] = 15"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Esto está pensado para permitir que los `Index` se compartan entre objetos sin riesgo de que se modifiquen en algún momento."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "bacteria2.index = bacteria.index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "phylum\n",
       "Firmicutes           NaN\n",
       "Proteobacteria     632.0\n",
       "Actinobacteria    1638.0\n",
       "Bacteroidetes      569.0\n",
       "dtype: float64"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bacteria2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Importing data\n",
    "\n",
    "En pirncipio es posible usar Python para leer cualquier archivo que uno desee, pero para el trabajo rutinario de un científico de datos esto es una opción de _demasiado bajo nivel_, NumPy provee de algunas funciones (como `genfromtxt` y `loadtxt`) para leer archivos que funcionan bastante bien para archivos relativamente simples. Pandas ofrece funciones  más vestátiles  y robustas para cuando nos encontramos con archivos _no tan simples_.\n",
    "\n",
    "Empecemos leyendo un archivo en formato csv (comma separated values)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Taxon,Paciente,Grupo,Tejido,Heces\r\n",
      "Firmicutes,1,0,136,4182\r\n",
      "Firmicutes,2,1,1174,703\r\n",
      "Firmicutes,3,0,408,3946\r\n",
      "Firmicutes,4,1,831,8605\r\n",
      "Firmicutes,5,0,693,50\r\n",
      "Firmicutes,6,1,718,717\r\n",
      "Firmicutes,7,0,173,33\r\n",
      "Firmicutes,8,1,228,80\r\n",
      "Firmicutes,9,0,162,3196\r\n"
     ]
    }
   ],
   "source": [
    "!head datos/microbiome.csv  # este es un comando de linux que nos permite ver las primeras lineas de un archivo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pandas ofrece una función llamada `read_csv` ideal para leer este tipo de datos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Taxon</th>\n",
       "      <th>Paciente</th>\n",
       "      <th>Grupo</th>\n",
       "      <th>Tejido</th>\n",
       "      <th>Heces</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Firmicutes</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>136</td>\n",
       "      <td>4182</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Firmicutes</td>\n",
       "      <td>2</td>\n",
       "      <td>1</td>\n",
       "      <td>1174</td>\n",
       "      <td>703</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Firmicutes</td>\n",
       "      <td>3</td>\n",
       "      <td>0</td>\n",
       "      <td>408</td>\n",
       "      <td>3946</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Firmicutes</td>\n",
       "      <td>4</td>\n",
       "      <td>1</td>\n",
       "      <td>831</td>\n",
       "      <td>8605</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Firmicutes</td>\n",
       "      <td>5</td>\n",
       "      <td>0</td>\n",
       "      <td>693</td>\n",
       "      <td>50</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "        Taxon  Paciente  Grupo  Tejido  Heces\n",
       "0  Firmicutes         1      0     136   4182\n",
       "1  Firmicutes         2      1    1174    703\n",
       "2  Firmicutes         3      0     408   3946\n",
       "3  Firmicutes         4      1     831   8605\n",
       "4  Firmicutes         5      0     693     50"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mb = pd.read_csv('datos/microbiome.csv')\n",
    "mb.head()  # le pedimos a Pandas que nos nuestre solo las primeras lineas, esto es similar al \"head\" de Linux!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Por defecto `read_csv` usará la primer linea del archivo como encabezado (_header_). Este comportamiento lo podemos modificar usando el argumento `header`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>0</th>\n",
       "      <th>1</th>\n",
       "      <th>2</th>\n",
       "      <th>3</th>\n",
       "      <th>4</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Taxon</td>\n",
       "      <td>Paciente</td>\n",
       "      <td>Grupo</td>\n",
       "      <td>Tejido</td>\n",
       "      <td>Heces</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Firmicutes</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>136</td>\n",
       "      <td>4182</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Firmicutes</td>\n",
       "      <td>2</td>\n",
       "      <td>1</td>\n",
       "      <td>1174</td>\n",
       "      <td>703</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Firmicutes</td>\n",
       "      <td>3</td>\n",
       "      <td>0</td>\n",
       "      <td>408</td>\n",
       "      <td>3946</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Firmicutes</td>\n",
       "      <td>4</td>\n",
       "      <td>1</td>\n",
       "      <td>831</td>\n",
       "      <td>8605</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            0         1      2       3      4\n",
       "0       Taxon  Paciente  Grupo  Tejido  Heces\n",
       "1  Firmicutes         1      0     136   4182\n",
       "2  Firmicutes         2      1    1174    703\n",
       "3  Firmicutes         3      0     408   3946\n",
       "4  Firmicutes         4      1     831   8605"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.read_csv('datos/microbiome.csv', header=None).head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Por defecto `read_csv` usa `,` como separadores, pero es posible modificar este comportamiento usando el argumento `sep`. Un caso muy común es el de archivos que tienen una cantidad variable de espacios en blanco. En esos casos podemos usar la [expresión regular](https://docs.python.org/2/library/re.html):\n",
    " \n",
    "    sep='\\s+'\n",
    "\n",
    "Que quiere decir use como separador 1 o más espacios en blanco. Otro caso común son archivos separados por tabulaciones, en ese caso podemos usar `\\t`.\n",
    "\n",
    "Ahora probemos con usar las dos primeras columnas como índices."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th>Grupo</th>\n",
       "      <th>Tejido</th>\n",
       "      <th>Heces</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Paciente</th>\n",
       "      <th>Taxon</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <th>Firmicutes</th>\n",
       "      <td>0</td>\n",
       "      <td>136</td>\n",
       "      <td>4182</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <th>Firmicutes</th>\n",
       "      <td>1</td>\n",
       "      <td>1174</td>\n",
       "      <td>703</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <th>Firmicutes</th>\n",
       "      <td>0</td>\n",
       "      <td>408</td>\n",
       "      <td>3946</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <th>Firmicutes</th>\n",
       "      <td>1</td>\n",
       "      <td>831</td>\n",
       "      <td>8605</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <th>Firmicutes</th>\n",
       "      <td>0</td>\n",
       "      <td>693</td>\n",
       "      <td>50</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                     Grupo  Tejido  Heces\n",
       "Paciente Taxon                           \n",
       "1        Firmicutes      0     136   4182\n",
       "2        Firmicutes      1    1174    703\n",
       "3        Firmicutes      0     408   3946\n",
       "4        Firmicutes      1     831   8605\n",
       "5        Firmicutes      0     693     50"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mb = pd.read_csv('datos/microbiome.csv', index_col=['Paciente','Taxon'])\n",
    "mb.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si queremos omitir datos (por ejemplo datos mal tomados), podemos indicaselo a Pandas usando el argumento `skiprows`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Taxon</th>\n",
       "      <th>Paciente</th>\n",
       "      <th>Grupo</th>\n",
       "      <th>Tejido</th>\n",
       "      <th>Heces</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Firmicutes</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>136</td>\n",
       "      <td>4182</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Firmicutes</td>\n",
       "      <td>2</td>\n",
       "      <td>1</td>\n",
       "      <td>1174</td>\n",
       "      <td>703</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Firmicutes</td>\n",
       "      <td>5</td>\n",
       "      <td>0</td>\n",
       "      <td>693</td>\n",
       "      <td>50</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Firmicutes</td>\n",
       "      <td>7</td>\n",
       "      <td>0</td>\n",
       "      <td>173</td>\n",
       "      <td>33</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Firmicutes</td>\n",
       "      <td>8</td>\n",
       "      <td>1</td>\n",
       "      <td>228</td>\n",
       "      <td>80</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "        Taxon  Paciente  Grupo  Tejido  Heces\n",
       "0  Firmicutes         1      0     136   4182\n",
       "1  Firmicutes         2      1    1174    703\n",
       "2  Firmicutes         5      0     693     50\n",
       "3  Firmicutes         7      0     173     33\n",
       "4  Firmicutes         8      1     228     80"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.read_csv('datos/microbiome.csv', skiprows=[3,4,6]).head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "También podemos indicarque que solo queremos importar unas pocas columnas, lo que puede ser muy útil cuando estamos haciendo pruebas y explorando los datos y queremos evitar importar un larga lista de datos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Taxon</th>\n",
       "      <th>Paciente</th>\n",
       "      <th>Grupo</th>\n",
       "      <th>Tejido</th>\n",
       "      <th>Heces</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Firmicutes</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>136</td>\n",
       "      <td>4182</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Firmicutes</td>\n",
       "      <td>2</td>\n",
       "      <td>1</td>\n",
       "      <td>1174</td>\n",
       "      <td>703</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Firmicutes</td>\n",
       "      <td>3</td>\n",
       "      <td>0</td>\n",
       "      <td>408</td>\n",
       "      <td>3946</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Firmicutes</td>\n",
       "      <td>4</td>\n",
       "      <td>1</td>\n",
       "      <td>831</td>\n",
       "      <td>8605</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "        Taxon  Paciente  Grupo  Tejido  Heces\n",
       "0  Firmicutes         1      0     136   4182\n",
       "1  Firmicutes         2      1    1174    703\n",
       "2  Firmicutes         3      0     408   3946\n",
       "3  Firmicutes         4      1     831   8605"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pd.read_csv('datos/microbiome.csv', nrows=4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Es común al analizar datos encontrarnos con datos faltantes. Las razones son variadas desde errores de transcripción, errores en la toma de muestra, observaciones incompletas, etc. En algunos casos estos datos faltantes quedan registrados simplemente como _huecos_ en los datos o usando alguno indicadores de datos faltantes como `NA` o `NULL` o _valores sentinelas_ como `999`, `-9999` (es decir valores que están _claramente_ fuera del rango de los datos). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Taxon,Patient,Tissue,Stool\r\n",
      "Firmicutes,1,632,305\r\n",
      "Firmicutes,2,136,4182\r\n",
      "Firmicutes,3,,703\r\n",
      "Firmicutes,4,408,3946\r\n",
      "Firmicutes,5,831,8605\r\n",
      "Firmicutes,6,693,50\r\n",
      "Firmicutes,7,718,717\r\n",
      "Firmicutes,8,173,33\r\n",
      "Firmicutes,9,228,NA\r\n"
     ]
    }
   ],
   "source": [
    "!head datos/microbiome_missing.csv"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Taxon</th>\n",
       "      <th>Patient</th>\n",
       "      <th>Tissue</th>\n",
       "      <th>Stool</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>Firmicutes</td>\n",
       "      <td>1</td>\n",
       "      <td>632</td>\n",
       "      <td>305.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>Firmicutes</td>\n",
       "      <td>2</td>\n",
       "      <td>136</td>\n",
       "      <td>4182.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>Firmicutes</td>\n",
       "      <td>3</td>\n",
       "      <td>NaN</td>\n",
       "      <td>703.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>Firmicutes</td>\n",
       "      <td>4</td>\n",
       "      <td>408</td>\n",
       "      <td>3946.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>Firmicutes</td>\n",
       "      <td>5</td>\n",
       "      <td>831</td>\n",
       "      <td>8605.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>Firmicutes</td>\n",
       "      <td>6</td>\n",
       "      <td>693</td>\n",
       "      <td>50.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>Firmicutes</td>\n",
       "      <td>7</td>\n",
       "      <td>718</td>\n",
       "      <td>717.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>Firmicutes</td>\n",
       "      <td>8</td>\n",
       "      <td>173</td>\n",
       "      <td>33.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>Firmicutes</td>\n",
       "      <td>9</td>\n",
       "      <td>228</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>Firmicutes</td>\n",
       "      <td>10</td>\n",
       "      <td>162</td>\n",
       "      <td>3196.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>Firmicutes</td>\n",
       "      <td>11</td>\n",
       "      <td>372</td>\n",
       "      <td>-99999.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11</th>\n",
       "      <td>Firmicutes</td>\n",
       "      <td>12</td>\n",
       "      <td>4255</td>\n",
       "      <td>4361.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>12</th>\n",
       "      <td>Firmicutes</td>\n",
       "      <td>13</td>\n",
       "      <td>107</td>\n",
       "      <td>1667.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>13</th>\n",
       "      <td>Firmicutes</td>\n",
       "      <td>14</td>\n",
       "      <td>?</td>\n",
       "      <td>223.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         Taxon  Patient Tissue    Stool\n",
       "0   Firmicutes        1    632    305.0\n",
       "1   Firmicutes        2    136   4182.0\n",
       "2   Firmicutes        3    NaN    703.0\n",
       "3   Firmicutes        4    408   3946.0\n",
       "4   Firmicutes        5    831   8605.0\n",
       "5   Firmicutes        6    693     50.0\n",
       "6   Firmicutes        7    718    717.0\n",
       "7   Firmicutes        8    173     33.0\n",
       "8   Firmicutes        9    228      NaN\n",
       "9   Firmicutes       10    162   3196.0\n",
       "10  Firmicutes       11    372 -99999.0\n",
       "11  Firmicutes       12   4255   4361.0\n",
       "12  Firmicutes       13    107   1667.0\n",
       "13  Firmicutes       14      ?    223.0"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mbm = pd.read_csv('datos/microbiome_missing.csv')\n",
    "mbm.head(14)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En el ejemplo anterior Pandas reconoció correctamente a `NA` y a un campo vacío como datos faltantes, pero pasó por alto a `?` y a `-99999`. Es facil pasar por alto estos errores, por lo que siemrpe es buena idea hacer gráficos de los datos y resúmenes como el siguiente:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Patient</th>\n",
       "      <th>Stool</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>count</th>\n",
       "      <td>75.000000</td>\n",
       "      <td>74.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>mean</th>\n",
       "      <td>8.000000</td>\n",
       "      <td>-619.283784</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>std</th>\n",
       "      <td>4.349588</td>\n",
       "      <td>11801.273013</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>min</th>\n",
       "      <td>1.000000</td>\n",
       "      <td>-99999.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>25%</th>\n",
       "      <td>4.000000</td>\n",
       "      <td>12.500000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>50%</th>\n",
       "      <td>8.000000</td>\n",
       "      <td>79.500000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>75%</th>\n",
       "      <td>12.000000</td>\n",
       "      <td>658.500000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>max</th>\n",
       "      <td>15.000000</td>\n",
       "      <td>8605.000000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         Patient         Stool\n",
       "count  75.000000     74.000000\n",
       "mean    8.000000   -619.283784\n",
       "std     4.349588  11801.273013\n",
       "min     1.000000 -99999.000000\n",
       "25%     4.000000     12.500000\n",
       "50%     8.000000     79.500000\n",
       "75%    12.000000    658.500000\n",
       "max    15.000000   8605.000000"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mbm.describe()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se puede ver que el conteo para `Paciente` y `Heces` no coinciden, que el valor más pequeño para `Heces` es un número negativo cuando debería ser mator o igual a cero. Y vemos que no tenémos descripción para `Tejido`! ¿Se te ocurre por que falta la columna para `Tejido`?\n",
    "\n",
    "Para especificar valores addicionales a considerar como datos faltantes usamos `na_values`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "mbm = pd.read_csv('datos/microbiome_missing.csv', na_values=['?', -99999])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Patient</th>\n",
       "      <th>Tissue</th>\n",
       "      <th>Stool</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>count</th>\n",
       "      <td>75.000000</td>\n",
       "      <td>73.000000</td>\n",
       "      <td>73.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>mean</th>\n",
       "      <td>8.000000</td>\n",
       "      <td>984.315068</td>\n",
       "      <td>742.082192</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>std</th>\n",
       "      <td>4.349588</td>\n",
       "      <td>1840.338155</td>\n",
       "      <td>1467.675342</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>min</th>\n",
       "      <td>1.000000</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>25%</th>\n",
       "      <td>4.000000</td>\n",
       "      <td>109.000000</td>\n",
       "      <td>14.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>50%</th>\n",
       "      <td>8.000000</td>\n",
       "      <td>310.000000</td>\n",
       "      <td>83.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>75%</th>\n",
       "      <td>12.000000</td>\n",
       "      <td>831.000000</td>\n",
       "      <td>661.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>max</th>\n",
       "      <td>15.000000</td>\n",
       "      <td>12044.000000</td>\n",
       "      <td>8605.000000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         Patient        Tissue        Stool\n",
       "count  75.000000     73.000000    73.000000\n",
       "mean    8.000000    984.315068   742.082192\n",
       "std     4.349588   1840.338155  1467.675342\n",
       "min     1.000000      0.000000     0.000000\n",
       "25%     4.000000    109.000000    14.000000\n",
       "50%     8.000000    310.000000    83.000000\n",
       "75%    12.000000    831.000000   661.000000\n",
       "max    15.000000  12044.000000  8605.000000"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mbm.describe()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si fuese necesario especificar valores distintos para distintas columnas es posible pasar un diccionario a `na_values`, indicando los nombres de las columnas y los valores a usar como indicadores. Este es un buen momento para que pruebes como hacer esto antes de seguir con la nueva sección."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Otros formatos\n",
    "\n",
    "Pandas ofrece la capacidad de leer varios otros formatos incluyendo archivos `xls`, `xlsx`, `JSON`, `XML`, `HDF5`, etc. PAra más información leer la documentación de Pandas o [Python for Data Analysis](http://shop.oreilly.com/product/0636920023784.do)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Indexado y selección en Series\n",
    "\n",
    "El idexado y selección en Pandas es muy parecido al de NumPy.\n",
    "\n",
    "Como ya vimos las series se pueden pensar como diccionarios o como arreglos unidimensionales. Los siguientes ejemplos muestra que ambas ideas son útiles."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "datos = pd.Series([0, .25, .5, .75], index=['a', 'b', 'c', 'd'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.25"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "datos['b']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'e' in datos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Index(['a', 'b', 'c', 'd'], dtype='object')"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "datos.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('a', 0.0), ('b', 0.25), ('c', 0.5), ('d', 0.75)]"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[_ for _ in datos.items()]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "a    0.00\n",
       "b    0.25\n",
       "c    0.50\n",
       "d    0.75\n",
       "e    1.00\n",
       "dtype: float64"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "datos['e'] = 1.\n",
    "datos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Al indexar con un índice implícito el último índice NO se incluye. Esto es lo que esperamos de listas, tuplas, arreglos etc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "b    0.25\n",
       "c    0.50\n",
       "dtype: float64"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "datos[1:3]  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Por lo que puede resultar confuso que al indexar con un índice explícito el último índice se incluye!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "b    0.25\n",
       "c    0.50\n",
       "d    0.75\n",
       "dtype: float64"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "datos['b':'d']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "d    0.75\n",
       "e    1.00\n",
       "dtype: float64"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "datos[datos > .5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "e    1.0\n",
       "a    0.0\n",
       "dtype: float64"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "datos[['e', 'a']]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Indexadores: loc e iloc\n",
    "\n",
    "La presencia de índices implícitos y explícitos puede ser una fuente de gran confusión al usar Pandas. Veamos, que sucede cuando tenemosuna serie con índices explícitos que son enteros."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "datos = pd.Series(['a', 'b', 'c'], index=[1, 3, 5])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pandas usará el índice explítico al indexar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'a'"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "datos[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pero el implícito al tomar rebanadas!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3    b\n",
       "5    c\n",
       "dtype: object"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "datos[1:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A fin de evitar confusiones Pandas provee de algunos métodos especiales para indexar. El primero de ellos es `loc` que permite hacer las operaciones de indexado/rebanado usando SIEMPRE el índice explícito."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'a'"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "datos.loc[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1    a\n",
       "3    b\n",
       "dtype: object"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "datos.loc[1:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "la contraparte de `loc` es `iloc` quien siemrpe usa el índice  **i**mplícito."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'b'"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "datos.iloc[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3    b\n",
       "5    c\n",
       "dtype: object"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "datos.iloc[1:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Siguiendo el zen de Python que nos dice que “explícito es mejor que implícito\". La recomendación general es usar `loc` e `iloc`. Ya que hace explícita la intención del código lo que ayuda a una más facil lectura y a reducir la posibilidad de errores."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'a'"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "datos.ix[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1    a\n",
       "3    b\n",
       "dtype: object"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "datos.ix[1:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Indexado y selección en DataFrames"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>pob</th>\n",
       "      <th>sup</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>BSAS</th>\n",
       "      <td>15594428</td>\n",
       "      <td>307571</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>CABA</th>\n",
       "      <td>2891082</td>\n",
       "      <td>202</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Córdoba</th>\n",
       "      <td>3304825</td>\n",
       "      <td>165321</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Mendoza</th>\n",
       "      <td>1741610</td>\n",
       "      <td>148827</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Santa Fe</th>\n",
       "      <td>3300736</td>\n",
       "      <td>133007</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "               pob     sup\n",
       "BSAS      15594428  307571\n",
       "CABA       2891082     202\n",
       "Córdoba    3304825  165321\n",
       "Mendoza    1741610  148827\n",
       "Santa Fe   3300736  133007"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pob = {'BSAS':15594428,'Córdoba':3304825, 'Santa Fe':3300736, 'CABA':2891082, 'Mendoza':1741610}\n",
    "sup = {'BSAS':307571,'Córdoba':165321, 'Santa Fe':133007, 'CABA':202, 'Mendoza':148827}\n",
    "\n",
    "datos = pd.DataFrame({'sup':sup, 'pob':pob})\n",
    "datos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como ya vimos es posible acceder a cada serie que forma un DataFrame usando una sintáxis simialr a la de los diccionarios"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "BSAS        307571\n",
       "CABA           202\n",
       "Córdoba     165321\n",
       "Mendoza     148827\n",
       "Santa Fe    133007\n",
       "Name: sup, dtype: int64"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "datos['sup']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O usando una sintáxis de atributo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "BSAS        307571\n",
       "CABA           202\n",
       "Córdoba     165321\n",
       "Mendoza     148827\n",
       "Santa Fe    133007\n",
       "Name: sup, dtype: int64"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "datos.sup"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La sintátix de atributo es solo _azucar sintáctico_ y podemos comprobar que devuelve exactamente el mismo objeto."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "datos.sup is datos['sup']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Esta sintáxis no funciona para todos los casos, Algunos casos donde fallará es si la columna continene espacios o si el nombre de la columna entra en conflicto con algún método existente para DataFrames, por ejemplo no sería raro que llamaramos a una columna con alguno de estos nombres `all`, `cov`, `index`, `mean`.\n",
    "\n",
    "Como ya vimos agregar una nueva columna a un DataFrame es similar a agregar un nuevo elemento a un diccionario."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>pob</th>\n",
       "      <th>sup</th>\n",
       "      <th>dens</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>BSAS</th>\n",
       "      <td>15594428</td>\n",
       "      <td>307571</td>\n",
       "      <td>50.701880</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>CABA</th>\n",
       "      <td>2891082</td>\n",
       "      <td>202</td>\n",
       "      <td>14312.287129</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Córdoba</th>\n",
       "      <td>3304825</td>\n",
       "      <td>165321</td>\n",
       "      <td>19.990352</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Mendoza</th>\n",
       "      <td>1741610</td>\n",
       "      <td>148827</td>\n",
       "      <td>11.702245</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Santa Fe</th>\n",
       "      <td>3300736</td>\n",
       "      <td>133007</td>\n",
       "      <td>24.816258</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "               pob     sup          dens\n",
       "BSAS      15594428  307571     50.701880\n",
       "CABA       2891082     202  14312.287129\n",
       "Córdoba    3304825  165321     19.990352\n",
       "Mendoza    1741610  148827     11.702245\n",
       "Santa Fe   3300736  133007     24.816258"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "datos['dens'] = datos['pob'] / datos['sup']\n",
    "datos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como ya vimos en la introducción a DataFrames, es posible ver estas estructuras de datos como arreglos de NumPy. Esto se hace evidente al quedarnos solo con los _valores_ de un DataFrame."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[  1.55944280e+07,   3.07571000e+05,   5.07018802e+01],\n",
       "       [  2.89108200e+06,   2.02000000e+02,   1.43122871e+04],\n",
       "       [  3.30482500e+06,   1.65321000e+05,   1.99903521e+01],\n",
       "       [  1.74161000e+06,   1.48827000e+05,   1.17022449e+01],\n",
       "       [  3.30073600e+06,   1.33007000e+05,   2.48162578e+01]])"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "datos.values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pero las similitudes son más amplias, por ejemplo podemos transponer un DataFrame al igual que un _arreglo_."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>BSAS</th>\n",
       "      <th>CABA</th>\n",
       "      <th>Córdoba</th>\n",
       "      <th>Mendoza</th>\n",
       "      <th>Santa Fe</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>pob</th>\n",
       "      <td>1.559443e+07</td>\n",
       "      <td>2.891082e+06</td>\n",
       "      <td>3.304825e+06</td>\n",
       "      <td>1.741610e+06</td>\n",
       "      <td>3.300736e+06</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>sup</th>\n",
       "      <td>3.075710e+05</td>\n",
       "      <td>2.020000e+02</td>\n",
       "      <td>1.653210e+05</td>\n",
       "      <td>1.488270e+05</td>\n",
       "      <td>1.330070e+05</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>dens</th>\n",
       "      <td>5.070188e+01</td>\n",
       "      <td>1.431229e+04</td>\n",
       "      <td>1.999035e+01</td>\n",
       "      <td>1.170224e+01</td>\n",
       "      <td>2.481626e+01</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "              BSAS          CABA       Córdoba       Mendoza      Santa Fe\n",
       "pob   1.559443e+07  2.891082e+06  3.304825e+06  1.741610e+06  3.300736e+06\n",
       "sup   3.075710e+05  2.020000e+02  1.653210e+05  1.488270e+05  1.330070e+05\n",
       "dens  5.070188e+01  1.431229e+04  1.999035e+01  1.170224e+01  2.481626e+01"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "datos.T"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Las similitudes de un DataFrame entre un diccionario y un arreglo entran en conflicto al querer indexarlo. Veamos, no sorprende que al pasar un solo índice"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([  1.55944280e+07,   3.07571000e+05,   5.07018802e+01])"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "datos.values[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "obtengamos la primer fila, esto es precisamente lo que se espera de un arreglo de NumPy. Pero hay que notar que al pasar un solo _índice_ a un DataFrame, lo que se obtiene es una columna y no una fila!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "BSAS        307571\n",
       "CABA           202\n",
       "Córdoba     165321\n",
       "Mendoza     148827\n",
       "Santa Fe    133007\n",
       "Name: sup, dtype: int64"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "datos['sup']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Por ello también existen indexadores especiales para DataFrames, `loc` e `iloc` ya los  conocemos de la sección anterior. Recordemos `loc` usa el índice explícito. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>pob</th>\n",
       "      <th>sup</th>\n",
       "      <th>dens</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>BSAS</th>\n",
       "      <td>15594428</td>\n",
       "      <td>307571</td>\n",
       "      <td>50.701880</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>CABA</th>\n",
       "      <td>2891082</td>\n",
       "      <td>202</td>\n",
       "      <td>14312.287129</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Córdoba</th>\n",
       "      <td>3304825</td>\n",
       "      <td>165321</td>\n",
       "      <td>19.990352</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "              pob     sup          dens\n",
       "BSAS     15594428  307571     50.701880\n",
       "CABA      2891082     202  14312.287129\n",
       "Córdoba   3304825  165321     19.990352"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "datos.loc[:'Córdoba']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Y ya que tenemos dos dimensiones para indexar podemos hacer selecciones como la siguiente:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>sup</th>\n",
       "      <th>dens</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>BSAS</th>\n",
       "      <td>307571</td>\n",
       "      <td>50.701880</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>CABA</th>\n",
       "      <td>202</td>\n",
       "      <td>14312.287129</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Córdoba</th>\n",
       "      <td>165321</td>\n",
       "      <td>19.990352</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            sup          dens\n",
       "BSAS     307571     50.701880\n",
       "CABA        202  14312.287129\n",
       "Córdoba  165321     19.990352"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "datos.loc[:'Córdoba', 'sup':]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Al usar `iloc` especificamos el índice implicito. Por lo que para obtener el mismo resultado que en la celda anterior hacemos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>sup</th>\n",
       "      <th>dens</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>BSAS</th>\n",
       "      <td>307571</td>\n",
       "      <td>50.701880</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>CABA</th>\n",
       "      <td>202</td>\n",
       "      <td>14312.287129</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Córdoba</th>\n",
       "      <td>165321</td>\n",
       "      <td>19.990352</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            sup          dens\n",
       "BSAS     307571     50.701880\n",
       "CABA        202  14312.287129\n",
       "Córdoba  165321     19.990352"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "datos.iloc[:3, 1:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "¿Y si quisieramos mezclar índices explítios e implícitos? En ese caso podemos usar `ix`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>pob</th>\n",
       "      <th>sup</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>BSAS</th>\n",
       "      <td>15594428</td>\n",
       "      <td>307571</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>CABA</th>\n",
       "      <td>2891082</td>\n",
       "      <td>202</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Córdoba</th>\n",
       "      <td>3304825</td>\n",
       "      <td>165321</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "              pob     sup\n",
       "BSAS     15594428  307571\n",
       "CABA      2891082     202\n",
       "Córdoba   3304825  165321"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "datos.ix[:3, :'sup']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El problema con `ix` es que si usamos enteros como índices explícitos, podemos terminar con el mismo tipo de confusiones que discutimos en la sección anterior. \n",
    "\n",
    "Como empezamos a ver en el capítulo sobre NumPy, es posible seleccionar subconjuntos de datos de forma muy versatil, estas capacidades se extienden a los DataFrames."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>sup</th>\n",
       "      <th>dens</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>BSAS</th>\n",
       "      <td>307571</td>\n",
       "      <td>50.701880</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>CABA</th>\n",
       "      <td>202</td>\n",
       "      <td>14312.287129</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         sup          dens\n",
       "BSAS  307571     50.701880\n",
       "CABA     202  14312.287129"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "datos.loc[datos.dens > 50, ['sup', 'dens']]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Funciones Universales\n",
    "\n",
    "Una de las características más valiosas de NumPY es la posiblidad de vectorizar código, evitando escribir _loops_, al realizar operaciones como sumas, multiplicaciones, logaritmos, etc. Pandas hereda de NumPy esta capacidad y la adapta de dos formas:\n",
    "\n",
    "1. Para operaciones unarias al aplicar funciones univerales se preserva el índice, es decir solo se aplican las operaciones a los valores y no a los _rótulos_.\n",
    "2. Para operaciones binarias, las mismas se realizan sobre los índices alineados\n",
    "\n",
    "Esto facilita el realizar operaciones que implican combinar datos de distintas fuentes, algo que puede no ser tan simple al usar NumPy.\n",
    "\n",
    "Veamos un ejemplo al operar con dos series a fin de calcular la densidad de población"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "BSAS           50.701880\n",
       "CABA        14312.287129\n",
       "Córdoba        19.990352\n",
       "Mendoza              NaN\n",
       "San Luis             NaN\n",
       "Santa Fe       24.816258\n",
       "dtype: float64"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pob = pd.Series({'BSAS':15594428,'Córdoba':3304825, 'Santa Fe':3300736, 'CABA':2891082, 'San Luis':476351}, name='pob')\n",
    "sup = pd.Series({'BSAS':307571,'Córdoba':165321, 'Santa Fe':133007, 'CABA':202, 'Mendoza':148827}, name='sub')\n",
    "\n",
    "pob / sup"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El resultado es una `Series` donde el índice corresponde a la _unión_ de los índices de `sup` y `pop`. Como para `san Luis` tenemos la población pero no la superficie y para `Mendoza` tenemos la  superficie pero no la población. El resultado es que en la nueva `Series` obtenemos `NaN` para estas dos provincias. \n",
    "\n",
    "Es posible cambiar este comportamiento al usar el método `.div()` el cual equivale a la división de la celda anterior, pero ahora podemos indicar que cambie `NaN` por otro valor."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "BSAS        5.070188e+01\n",
       "CABA        1.431229e+04\n",
       "Córdoba     1.999035e+01\n",
       "Mendoza     0.000000e+00\n",
       "San Luis             inf\n",
       "Santa Fe    2.481626e+01\n",
       "dtype: float64"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pob.div(sup, fill_value=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El cambio se realiza antes de realizar la operación, por eso obtenemos `0` para `Mendoza` e `inf` para San Luis. Una variante sería hacer la operación y luego cambiar los `NaN` por cualquier otro valor (incluso uno con muy poco sentido)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "BSAS        50.7019\n",
       "CABA        14312.3\n",
       "Córdoba     19.9904\n",
       "Mendoza           ϵ\n",
       "San Luis          ϵ\n",
       "Santa Fe    24.8163\n",
       "dtype: object"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(pob / sup).fillna('ϵ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En los DataFrames el _alineamiento_ tiene en cuenta  tanto las columnas comos los índices."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>A</th>\n",
       "      <th>B</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>3</td>\n",
       "      <td>4</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   A  B\n",
       "0  1  2\n",
       "1  3  4"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = pd.DataFrame(np.arange(1, 5).reshape(2, 2), columns=['A', 'B'])\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>B</th>\n",
       "      <th>A</th>\n",
       "      <th>C</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>10</td>\n",
       "      <td>11</td>\n",
       "      <td>12</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>13</td>\n",
       "      <td>14</td>\n",
       "      <td>15</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>16</td>\n",
       "      <td>17</td>\n",
       "      <td>18</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    B   A   C\n",
       "0  10  11  12\n",
       "1  13  14  15\n",
       "2  16  17  18"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B = pd.DataFrame(np.arange(10, 19).reshape(3, 3), columns=['B', 'A', 'C'])\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>A</th>\n",
       "      <th>B</th>\n",
       "      <th>C</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>12.0</td>\n",
       "      <td>12.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>17.0</td>\n",
       "      <td>17.0</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      A     B   C\n",
       "0  12.0  12.0 NaN\n",
       "1  17.0  17.0 NaN\n",
       "2   NaN   NaN NaN"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A + B"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como habrás podido ver los índices quedan alineados correctamente independientemente de su orden en los objetos originales.\n",
    "\n",
    "Como en el caso de `Series`, podemos utilizar las el método aritmético del objeto y pasar cualquier valor de relleno que deseemos, por ejemplo la media de todos los valores en A."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>A</th>\n",
       "      <th>B</th>\n",
       "      <th>C</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>12.0</td>\n",
       "      <td>12.0</td>\n",
       "      <td>14.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>17.0</td>\n",
       "      <td>17.0</td>\n",
       "      <td>17.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>19.5</td>\n",
       "      <td>18.5</td>\n",
       "      <td>20.5</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      A     B     C\n",
       "0  12.0  12.0  14.5\n",
       "1  17.0  17.0  17.5\n",
       "2  19.5  18.5  20.5"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fill = A.values.mean()\n",
    "A.add(B, fill_value=fill)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Por supuesto también podemos combinar operacioens entre `Series` y `DataFrames` y Pandas se ocupará de mantener los \"rótulos\" alineados."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>B</th>\n",
       "      <th>A</th>\n",
       "      <th>C</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>3</td>\n",
       "      <td>3</td>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>6</td>\n",
       "      <td>6</td>\n",
       "      <td>6</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   B  A  C\n",
       "0  0  0  0\n",
       "1  3  3  3\n",
       "2  6  6  6"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B - B.iloc[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La operación anterior se realizó a lo largo de las filas (como se esperaría en NumPy), si quisieramos hacerlo a lo largo de las columnas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>B</th>\n",
       "      <th>A</th>\n",
       "      <th>C</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   B  A  C\n",
       "0  0  1  2\n",
       "1  0  1  2\n",
       "2  0  1  2"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B.subtract(B['B'], axis=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Datos Faltantes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "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.5.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}