guia-de-pandas-python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Guia rápida de Pandas\n",
    "Compilada por Brenda Hali\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Instalación\n",
    "La librebria de Pandas está contruida basada en NumPy, para evitar errores, primero instalemos NumPy. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!pip install numpy\n",
    "!pip install pandas #Estas dos líneas instalan las librerías"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Importando las librerías"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd #Estas dos líneas importan las librerías"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Estructura de los datos\n",
    "- Panda soporta dataframes hasta de dos dimensiones\n",
    "- Objetos de una dimensión son llamados Series. \n",
    "- Objetos de dos dimensiones son llamados DataFrames.\n",
    "- La estructura de los datos son Rows (filas) y Columns (columnas). \n",
    "\n",
    "#### Los básicos\n",
    "Encuentra la documentación de Pandas aqui https://pandas.pydata.org/pandas-docs/stable/getting_started/basics.html\n",
    "\n",
    "#### Leer datos desde un documento\n",
    "Puedes leer data en formato cvs, sql, json, html, entre otros. \n",
    "- Lee aqui todas las opciones de formatos que puede importar a pandas \n",
    "https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.read_csv.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.read_csv('file.csv') #Importa el documento\n",
    "df = pd.read_csv('file.csv', index_col=0) #Toma la columna 0 como el índice\n",
    "df = pd.read_html(url) #Importa HTML, necesitas tener BeautifulSoup para manipulación de datos\n",
    "\n",
    "#Otras opciones\n",
    "df = pd.read_json()\n",
    "df = pd.read_sql()\n",
    "df = pd.read_excel()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Guardar el DataFrame como archivo\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.to_csv('file_name.csv',index=False) #Esta opción guardará el DataFrame como csv sin índice indicado\n",
    "\n",
    "#Opciones\n",
    "df.to_json()\n",
    "df.to_sql()\n",
    "pd.to_excel()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Cambiar los tipos de datos\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pd.to_datetime\n",
    "pd.to_timedelta"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Atributos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.columns #Regresa las columnas del DataFrame\n",
    "df.dtypes #Regresa los tipos de datos\n",
    "df.index #Regresa el indice\n",
    "df.shape #Regresa la forma (cantidad de filas y columnas)\n",
    "df.T #Regresa el DataFrame invertido (horizontal-vertical)\n",
    "df.values #Regresa los valores"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Combinaciones del DataFrame Join, Merge y Concat\n",
    "Puedes leer toda la documentación aquí: https://pandas.pydata.org/pandas-docs/stable/user_guide/merging.html\n",
    "\n",
    "Ajustes comunes\n",
    "\n",
    "- `ignore_index = True`-  Cuando el indice no  es relevante para la combinación\n",
    "- `axis= 0`: agrega en filas | `axis= 1` agrega en columnas\n",
    "- `keys = ['a', 'b', 'c']`-  agrega la data que está en llaves específicas\n",
    "- `left` join - Solo usa las llaves del DataFrame a la izquierda\n",
    "- `right` join - Usa llaves del DataFrame de la derecha\n",
    "- `outer` - Usa las llaves unidas contenidas en los dos DataFrames\n",
    "- `inner` - Usa la intersección de llaven en los dos dataframes\n",
    "\n",
    "Si quieres modificar permanentemente el DataFrame,  `inplace=True` necesita ser específicado."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_1.join(df_2) #Esto mezcla los dos dataframes basado en el Indice - Deben tener el mismo indice\n",
    "\n",
    "pd.concat([df_1, df_2], axis=1, join='outer', ignore_index=False, keys=None,\n",
    "          levels=None, names=None, verify_integrity=False, copy=True)\n",
    "\n",
    "df_1.pd.append(df_2, sort = True, inplace = True) \n",
    "\n",
    "dataframes = {'a': df_1, 'b': df_2, 'c': df_3}\n",
    "new_df  = pd.concat(dataframes) \n",
    "pd.merge(left, right, how='inner', on=None, left_on=None, right_on=None,\n",
    "         left_index=False, right_index=False, sort=True,\n",
    "         suffixes=('_x', '_y'), copy=True, indicator=False,\n",
    "         validate=None)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Creación de nuevas columnas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df['sum_col1_col2'] = df['col_1'] + df['col_2']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Explorar el DataFrame sin cambiar los valores permanentemente\n",
    "Si deseas hacer algun cambio permanente, debes indicar (inplace = True)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.head() #Regresa los primeros 5 valores\n",
    "\n",
    "df.tail() #Regresa los últimos 5 valores\n",
    "\n",
    "df['column_name'] #Regresa todos los valores de la columna específicada\n",
    "df.column_name #Regresa todos los valores de la columna especificada\n",
    "df['column_name', 'second_column'] #Regresa las columnas indicadas en un nuevo DataFrame\n",
    "df[7:9] #Imprime las columnas indicadas por su número de índice\n",
    "df.value_counts(dropna=True)  #Regresa todos los valores quitando los null values\n",
    "df.sort_index(axis=0, ascending=False) #Returns dataframe sorted by index\n",
    "df.apply(pd.Series.value_counts) #Regresa la suma de cada valor por columna\n",
    "df.sort_values(by='column_name') #Regresa el DataFrame ordernado por la columna seleccionada\n",
    "df.groupby('column_name').mean() #Regresa el DataFrame ordenado por la media de la columna seleccionada\n",
    "df.pivot_table #PivotTable\n",
    "df.iloc[0] #Selecciona el primer valor\n",
    "df.loc['index_one'] #Seleccion basada en el index\n",
    "df.iloc[0,:]  #Regresa la primera fila\n",
    "df.iloc[0,0] #Regresa el primer elemento del DataFrame\n",
    "\n",
    "#Algunos ejemplos que pueden ser adaptados como sea necesario\n",
    "\n",
    "df[df['is_muy_value'] == 1][['what_im_looking_for']]\n",
    "\n",
    "df[df['column_1'] < 10].groupby('column_2').mean()[['what_im_looking_for']]\n",
    "df[df['column_1'] == 0].sort_values(by='column_2', ascending=False).head()\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Remplazar y renombrar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.columns = ['column_1', 'column_2'] #Renombra las columnas\n",
    "df.rename(columns={'old_name': 'new_ name'}) #Selecciona las columnas y las renombra con el nuevo valor\n",
    "\n",
    "df.replace(1,'one') #En este ejemplo reemplaza todos los valores 1 con one\n",
    "\n",
    "df.replace([1,3],['one','three']) #Reemplaza los 1 por ‘one’ y los 3 por ‘three’\n",
    "\n",
    "\n",
    "df.set_index('column_1') #Cambia el indice por la columna seleccionada\n",
    "\n",
    "df.astype(int) # Convierte el tipo de dato\n",
    "\n",
    "df['column_1'].astype(int) #cambia el tipo de dato de la columna seleccionada"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Valores Nulos o Null y NaNs\n",
    "\n",
    "- `isna`  `isnull`\n",
    "- `notna` `notnull`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.fillna(value = 'my_selected_value', inplace = True) # Rellena todos los valores inexistentes permanentemente\n",
    "df.fillna(x) # Reemplaza todos los valores inexistentes con una X\n",
    "df.notna().sum() #Suma todos los valores que no son NA \n",
    "df.interpolate()\n",
    "df.isna().sum() #Regresa todos los valores que son NA\n",
    "df.isnull()\n",
    "df.dropna(inplace = True) # Suelta o elimina los valores Na de forma permanente\n",
    "df.isnull().sum() #Imprime los valores nulos por columna\n",
    "df.isnull().sum()[df.isnull().sum() !=0].sort_values().plot(kind='barh'); #Grafíca los valores nulos por columna\n",
    "df.fillna(df.mean()) #Reemplaza los NAs con la media de los numeros\n",
    "\n",
    "#Otra forma de sobreescribir en el DataFrame sin los valores nulos o inexistentes en ciertas columnas\n",
    "\n",
    "df.column.fillna(value='no_info', inplace=True) \n",
    "df= df.loc[df['column'] != 'no_info']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 'Dropping' - Soltar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.drop(['column_1', 'column_2'], axis=1, inplace = True) #Suelta los valores de columnas específicas\n",
    "df.drop_duplicates(inplace=True) #Suelta los valores duplicados permanentemente\n",
    "df.drop('row_1', axis=0, inplace = True) #Suelta una columna de forma permanente"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Métodos estadísticos\n",
    "Puedem ser usados en conjunto con `df.sum` y `df.sum()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.describe() #Regresa las estadísticas de un DataFrame\n",
    "df.max() #Regresa el valor máximo\n",
    "df.mean() #Regresa la media\n",
    "df.median() #Regresa la mediana\n",
    "df.min() # Regresa el valor mínimo de cada columna\n",
    "df.mode() #Regresa la moda\n",
    "df.std() # Regresa la desviación estándar de cada columna\n",
    "df.var() #Regresa la varianza\n",
    "df.abs() #Regresa los valores absolutos\n",
    "df.corr() #Regresa las correlaciones en un DataFrame\n",
    "df.round() #Redondea los números"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Más que explorar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.clip()\n",
    "df.nunique() \n",
    "df.idxmax()\n",
    "df.idxmin()\n",
    "df.cov()\n",
    "df.cummax()\n",
    "df.cummin()\n",
    "df.cumprod()\n",
    "df.cumsum()\n",
    "df.diff()\n",
    "df.nlargest()\n",
    "df.nsmallest()\n",
    "df.pct_change()\n",
    "df.prod()\n",
    "df.quantile()\n",
    "df.rank()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Variables Dummy \n",
    "https://socialresearchmethods.net/kb/dummyvar.php"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.get_dummies(df, columns=['my_column'], drop_first=True)\n",
    "#Cuando hacemos valiables dummies, soltamos la primera columna para que no sea redundante"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ejemplos en código"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Exploración de datos inicial\n",
    "def df_EDA(df):\n",
    "    print('SHAPE:', df.shape)\n",
    "    print('----------------')\n",
    "    print('SUM OF NULL VALUES:', df.isnull().sum())\n",
    "    print('----------------')\n",
    "    print('DATA TYPES:')\n",
    "    print(df.dtypes)\n",
    "    print('----------------')\n",
    "    print('DESCRIPTIVE STATISTICS:')\n",
    "    return df.describe().T\n",
    "\n",
    "df_EDA(your_df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Esta columna tiene el valor que estoy buscando?\n",
    "def is_the_value_im_looking(i):\n",
    "    val = i.split()\n",
    "    if 'value' in str(val):\n",
    "        return 1\n",
    "    else:\n",
    "        return 0\n",
    "    \n",
    "#Crea un columna llamada como el valor que estoy buscando\n",
    "df['value'] = df['col_1'].apply(is_the_value_im_looking)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Extrae el titulo de cada nombre y crea las variables dummies con comprensión de listas\n",
    "#TPuede adaptarse como sea necesario\n",
    "\n",
    "df['Title'] = [each.split(',')[1].split('.')[0].strip() for each in df['Name']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Rate por columna \n",
    "#Puede adaptarse como sea necesario.\n",
    "\n",
    "for i in ['column_1', 'column_2', 'column_3']:\n",
    "    print(i, ':')\n",
    "    print(df[df[i] == 1][['the_value_im_lookingfor']].mean())\n",
    "    print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Graficando\n",
    "Ejemplos de graficación"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.isnull().sum()[df.isnull().sum() !=0].sort_values().plot(kind='barh'); #Grafíca los valores nulos por columna"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.groupby('column_1').mean()[['value']].plot(kind='barh')\n",
    "plt.title('Nombre de la gráfica');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.groupby(['column_1', 'colum_2']).mean()[['value']].plot(kind='barh');"
   ]
  }
 ],
 "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}