PANDAS - Manipulacion de Datos con Python

Por Jose R. Zapata

Pandas es una herramienta de manipulación de datos de alto nivel desarrollada por Wes McKinney. Es construido sobre Numpy y permite el análisis de datos que cuenta con las estructuras de datos que necesitamos para limpiar los datos en bruto y que sean aptos para el análisis (por ejemplo, tablas). Como Pandas permite realizar tareas importantes, como alinear datos para su comparación, fusionar conjuntos de datos, gestión de datos perdidos, etc., se ha convertido en una librería muy importante para procesar datos a alto nivel en Python (es decir, estadísticas ). Pandas fue diseñada originalmente para gestionar datos financieros, y como alternativo al uso de hojas de cálculo (es decir, Microsoft Excel).

Los principales tipos de datos que pueden representarse con pandas son:

• Datos tabulares con columnas de tipo heterogéneo con etiquetas en columnas y filas.
• Series temporales

Pandas proporciona herramientas que permiten:

• leer y escribir datos en diferentes formatos: CSV, JSON, Excel, bases SQL y formato HDF5
• seleccionar y filtrar de manera sencilla tablas de datos en función de posición, valor o etiquetas
• fusionar y unir datos
• transformar datos aplicando funciones tanto en global como por ventanas
• manipulación de series temporales
• hacer gráficas

En pandas existen tres tipos básicos de objetos todos ellos basados a su vez en Numpy:

• Series (listas, 1D)
• DataFrame (tablas, 2D)

Por lo tanto, Pandas nos proporciona las estructuras de datos y funciones necesarias para el análisis de datos.

Instalar Pandas

Pandas ya esta preinstalado si se usa Google Collaboratory, si va realizar una instalacion en su computador

PIP

pip install pandas

Conda

Si instalo Anaconda, pandas ya viene preinstalado

conda install pandas

Importando Pandas

La libreria Pandas se importa de la siguiente manera

import pandas as pd # Importacion estandar de la libreria Pandas
import numpy  as np # Importacion estandar de la libreria NumPy

Series

Una serie es el primer tipo de datos de pandas y es muy similar a una matriz NumPy (de hecho está construida sobre el objeto de matriz NumPy). Lo que diferencia un arreglo NumPy de una serie, es que una serie puede tener etiquetas en los ejes, lo que significa que puede ser indexada por una etiqueta, en lugar de solo una ubicación numérica. Tampoco necesita contener datos numéricos, puede contener cualquier Objeto de Python arbitrario.

Creando una Serie

Puede convertir una lista, una matriz numpy o un diccionario en una serie, usando el metodo pd.Series:

# Crear diferentes tipos de datos
labels = ['a','b','c'] # lista de eetiquetas
my_list = [10,20,30] # lista con valores
arr = np.array([10,20,30]) # Convertir ista de valores en arreglo NumPy
d = {'a':10,'b':20,'c':30} # Creacion de un diccionario

Desde Listas

# Convertir una lista en series usando el metodo pd.Series
# observe que se crean los nombres con las posiciones de cada elemento
pd.Series(data=my_list)

0    10
1    20
2    30
dtype: int64

# Convertir una lista en series usando el metodo pd.Series
# se puede ingresar el nombre de las posiciones
pd.Series(data=my_list,index=labels)

a    10
b    20
c    30
dtype: int64

# No es necesario ingresar la palabra de 'data =''  en el argumento
pd.Series(my_list,labels)

a    10
b    20
c    30
dtype: int64

Desde Arreglos NumPy

# Convertir un arreglo en series usando el metodo pd.Series
pd.Series(arr)

0    10
1    20
2    30
dtype: int64

# Convertir un arreglo en series indicando tambien los valores del index
pd.Series(arr,labels)

a    10
b    20
c    30
dtype: int64

Desde un Diccionario

# Convertir un diccionario en series usando el metodo pd.Series
# Como el diccionario ya tiene clave entonces se le asigna como valor de la posicion
pd.Series(d)

a    10
b    20
c    30
dtype: int64

Datos en una Series

Una serie de pandas puede contener una variedad de tipos de objetos:

# Creando una serie basado solo en una lista de letras
pd.Series(data=labels)

0    a
1    b
2    c
dtype: object

Indexacion

La clave para usar una serie es entender su índice. Pandas hace uso de estos nombres o números de índice al permitir búsquedas rápidas de información (funciona como una tabla hash o diccionario).

Veamos algunos ejemplos de cómo obtener información de una serie. Vamos a crear dos series, ser1 y ser2:

# Creacion de una serie con sus labels o indices
ser1 = pd.Series([1,2,3,4],index = ['USA', 'Germany','USSR', 'Japan'])                                   

ser1

USA        1
Germany    2
USSR       3
Japan      4
dtype: int64

# Creacion de una serie con sus labels o indices
ser2 = pd.Series([1,2,5,4],index = ['USA', 'Germany','Italy', 'Japan'])                                   

ser2

USA        1
Germany    2
Italy      5
Japan      4
dtype: int64

# La busqueda en una serie es igual como en un diccionario
ser1['USA']

1

# La busqueda en una serie es igual como en un diccionario
ser2['Germany']

2

Las operaciones también se realizan según el índice:

# Observe los resultados de los paises que solo estan en una serie y no en las dos
ser1 + ser2

Germany    4.0
Italy      NaN
Japan      8.0
USA        2.0
USSR       NaN
dtype: float64

DataFrames

Los DataFrames son la estructura mas importante en pandas y están directamente inspirados en el lenguaje de programación R. Se puede pensar en un DataFrame como un conjunto de Series reunidas que comparten el mismo índice. En los DataFrame tenemos la opción de especificar tanto el index (el nombre de las filas) como columns (el nombre de las columnas).

# Importar la funcion de NumPy para crear arreglos de numeros enteros
from numpy.random import randn
np.random.seed(101) # Inicializar el generador aleatorio

# Forma rapida de crear una lista de python desde strings
'A B C D E'.split()

['A', 'B', 'C', 'D', 'E']

# Crear un dataframe con numeros aleatorios de 4 Columnas y 5 Filas
# Crear listas rapidamente usando la funcion split 'A B C D E'.split()
# Esto evita tener que escribir repetidamente las comas

df = pd.DataFrame(randn(5,4),
                  index='A B C D E'.split(),
                  columns='W X Y Z'.split())

df

Descripcion general del dataframe

Numero de Filas y Columnas

df.shape # retorna un Tuple asi: (filas, col)

(5, 4)

Informacion General de los datos

# Informacion general de los datos de cada cloumna
# Indica el numero de filas del dataset
# Muestra el numero de datos No Nulos por columna (valores validos)
# Tipo de dato de cada columna
# Tamaño total del dataset
df.info()

<class 'pandas.core.frame.DataFrame'>
Index: 5 entries, A to E
Data columns (total 4 columns):
W    5 non-null float64
X    5 non-null float64
Y    5 non-null float64
Z    5 non-null float64
dtypes: float64(4)
memory usage: 200.0+ bytes

# Tipos de datos que existen en las columnas del dataframe
df.dtypes

W    float64
X    float64
Y    float64
Z    float64
dtype: object

Resumen de estadistica descriptiva General

el metodo .describe() de los dataframes presenta un resumen de la estadistica descriptiva general de las columnas numericas del dataframe, presenta la informacion de:

• Promedio (mean)
• Desviacion estandard (std)
• Valor minimo
• Valor maximo
• Cuartiles (25%, 50% y 75%)

df.describe() # No muestra la informacion de las columnas categoricas

Ver Primeros elementos del dataframe

df.head()

Ver Ultimos elementos del dataframe

df.tail()

Seleccion y Indexacion

Existen diversos métodos para tomar datos de un DataFrame

# Regresara todos los datos de la columna W
df['W']

A    2.706850
B    0.651118
C   -2.018168
D    0.188695
E    0.190794
Name: W, dtype: float64

# Seleccionar dos o mas columnas
# Pasar una lista con los nombres de las columnas

df[['W','Z']]

# Seleccionar dos o mas columnas
# Pasar una lista con los nombres de las columnas
# Puedo indicar el orden de las columnas

df[['X','W','Z']] 

Las columnas de un DataFrame Columns son solo Series

type(df['W']) # Tipos de datos

pandas.core.series.Series

Creando una Nueva Columna

# Nueva columna igual a la suma de otras dos
# operacion vectorizada
df['new'] = df['W'] + df['Y']
df

Eliminando Columnas

df.drop('new',axis=1) # axis = 0 elimina filas(index) axis = 1 elimina columnas

# No se aplica a el dataframe a menos que se especifique.
# Como se ve la operacion pasada no quedo grabada
df

# Para que quede grabado se puede hacer de dos formas
# df = df.drop('new',axis=1) # Forma 1
df.drop('new', axis=1, inplace=True) # Forma 2
df

df

También se puede sacar filas de esta manera:

df.drop('E',axis=0)

df

# Otra manera de borrar las columnas es
del df['X'] # Esta funcion es INPLACE
df 

Obtener los nombres de las columnas y los indices (index):

df.columns # nombres de las columnas

Index(['W', 'Y', 'Z'], dtype='object')

df.index # nombres de los indices

Index(['A', 'B', 'C', 'D', 'E'], dtype='object')

Seleccionando Filas y Columnas

las dos formas de seleccion principal son:

• DataFrame.loc[etiqueta_fila, etiqueta_columna] <- por etiquetas
• DataFrame.iloc[indice_fila, indice_columna] <- por indices

# la funcion loc busca por medio de los nombres de los indices y columnas
df.loc['A'] # se selecciona todos los valores de la fila 'A'

W    2.706850
Y    0.907969
Z    0.503826
Name: A, dtype: float64

O basado en la posicion (index) en vez de usar la etiqueta

df.iloc[2] # Se seleccionan los valores de la fila con indice 2
# recordar que los index empiezan en cero

W   -2.018168
Y    0.528813
Z   -0.589001
Name: C, dtype: float64

Seleccionar un subconjunto de filas y columnas

# Mediante etiquetas
# se selecciona el elemento que esta en la fila=B Col=Y
df.loc['B','Y'] # con etiquetas

-0.8480769834036315

# Mediante etiquetas
# se selecciona un subconjunto de datos que estan entre
# filas = A, B   Cols= W, Y
df.loc[['A','B'],['W','Y']]

df.loc[['B','A'],['Y','W']]

Seleccion Condicional o Filtros

Una característica importante de pandas es la selección condicional usando la notación de corchetes, muy similar a NumPy:

df

# Devuelve un dataframe con booleans
# segun si se cumple o no la condicion
df>0

# Esta operacion solo mostrara los valores del dataframe que cumplen la condicion
# los que no cumplen devuelve el valor NaN
df[df>0]

# seleccionar todas las filas donde el valor
# que esta en la columna 'W' sea mayor que cero
df[df['W']>0]

# Seleccionar las filas donde 'W' sea mayor que cero
# y de esas filas escoger los valores de la columna 'Y'
df[df['W']>0]['Y']

A    0.907969
B   -0.848077
D   -0.933237
E    2.605967
Name: Y, dtype: float64

# Seleccionar las filas donde 'W' sea mayor que cero
# y de esas filas escoger los valores de las columna 'Y' y 'X'
df[df['W']>0][['Y','Z']]

Para dos condiciones, se usa los booleanos de esta forma

• | en vez de or
• & en vez de and
• ~ en vez de not

Por amor a Dios, recuerde usar paréntesis:

# Seleccionar las filas donde 'W' sea mayor que cero
# y tambien donde 'Y' sea mayor que 0.5
df[(df['W']>0) & (df['Y'] > 0.5)]

.query() Busqueda condicional

Los terminos de busqueda condicional o filtros se entregan al metodo como tipo ‘string’

df

# seleccionar todas las filas donde el valor
# que esta en la columna 'W' sea mayor que cero

#df[df['W']>0]
df.query('W>0')

# Seleccionar las filas donde 'W' sea mayor que cero
# y de esas filas escoger los valores de la columna 'Y'

#df[df['W']>0]['Y']
df.query('W>0')['Y']

A    0.907969
B   -0.848077
D   -0.933237
E    2.605967
Name: Y, dtype: float64

# Seleccionar las filas donde 'W' sea mayor que cero
# y de esas filas escoger los valores de las columna 'Y' y 'X'

#df[df['W']>0][['Y','Z']]
df.query('W>0')[['Y','Z']]

Para dos condiciones, puede usar | = or y & = and con paréntesis:

# Seleccionar las filas donde 'W' sea mayor que cero
# y tambien donde 'Y' sea mayor que 0.5

#df[(df['W']>0) & (df['Y'] > 0.5)]
df.query('W>0 and Y>0.5')

Cambio de columna de Indexacion

Analicemos algunas características más de la indexación, incluido el restablecimiento del índice o el establecimiento de parametros.

df

# Reinicializar el indice a su valor por defecto 0,1...n index
df = df.reset_index()
df

newind = 'CA NY WY OR CO'.split() # crear una lista con strings
newind

['CA', 'NY', 'WY', 'OR', 'CO']

# Agregar la lista creaada en el paso anterior al dataframe
df['States'] = newind
df

# Redefinir la columna states como el indice
df.set_index('States')

# por que no queda establecido el indice?
df

# para establecer el indice debe ser una funcion inplace
df.set_index('States',inplace=True)
#df = df.set_index('States') # otra forma de hacerlo

df

---

Groupby (Agrupacion por filas)

El método groupby le permite agrupar filas de datos y llamar a funciones agregadas

import pandas as pd
# Crear dataframe desde un diccionario
data = {'Company':['GOOG','GOOG','MSFT','MSFT','FB','FB'],
       'Person':['Sam','Charlie','Amy','Vanessa','Carl','Sarah'],
       'Sales':[200,120,340,124,243,350]}
data

{'Company': ['GOOG', 'GOOG', 'MSFT', 'MSFT', 'FB', 'FB'],
 'Person': ['Sam', 'Charlie', 'Amy', 'Vanessa', 'Carl', 'Sarah'],
 'Sales': [200, 120, 340, 124, 243, 350]}

#conversion del diccionario a dataframe
df = pd.DataFrame(data)
df

Se puede usar el método .groupby() para agrupar filas en función de un nombre de columna. Por ejemplo, vamos a agruparnos a partir de la Compañía. Esto creará un objeto DataFrameGroupBy:

#agrupar por Company
df.groupby('Company')

<pandas.core.groupby.generic.DataFrameGroupBy object at 0x7f059acb5128>

Se puede grabar este objeto en una nueva variable:

by_comp = df.groupby("Company")

utilizar los métodos agregados del objeto:

# Promedio de ventas por company
by_comp.mean()

# agrupar por compañia y calcular el promedio por cada una
df.groupby('Company').mean()

Más ejemplos de métodos agregados:

# agrupar por compañia y calcular la desviacion estandard
by_comp.std()

# agrupar por compañia y calcular el minimo
by_comp.min()

# agrupar por compañia y calcular el maximo
by_comp.max()

# agrupar por compañia y sumar los elementos que hay excluyendo los NaN
by_comp.count()

# Una de las funciones mas usadas para descripcion estadistica de un dataframe
# Genera estadísticas descriptivas que resumen la tendencia central, la dispersión y la forma de la distribución de un conjunto de datos, excluyendo los valores `` NaN``.
# by_comp.describe(include = 'all') # incluir todo
by_comp.describe()

# Una de las funciones mas usadas para descripcion estadistica de un dataframe
# Genera estadísticas descriptivas que resumen la tendencia central, la dispersión y la forma de la distribución de un conjunto de datos, excluyendo los valores `` NaN``.
# Transponer la descripcion
by_comp.describe().transpose()

# Descripcion estadistica de los datos de la copmañia GOOG
by_comp.describe().transpose()['GOOG']

Sales  count      2.000000
       mean     160.000000
       std       56.568542
       min      120.000000
       25%      140.000000
       50%      160.000000
       75%      180.000000
       max      200.000000
Name: GOOG, dtype: float64

Pivot Tables

La funcionlidad “Pivot_table” es muy utilizada y popular en las conocidas “hojas de cálculo” tipo, OpenOffice, LibreOffice, Excel, Lotus, etc. Esta funcionalidad nos permite agrupar, ordenar, calcular datos y manejar datos de una forma muy similar a la que se hace con las hojas de cálculo. mas informacion

La principal función del “Pivot_table” son las agrupaciones de datos a las que se les suelen aplicar funciones matemáticas como sumatorios, promedios, etc

import seaborn as sns # importar la libreria seaborn
# cargar dataset del titanic
titanic = sns.load_dataset('titanic')
titanic.head()

Haciendo el Pivot table a mano para obtener el promedio de personas que sobrevivieron por genero

# 1. Agrupar por genero
# 2. Obtener los sobrevivientes
# 3. Calcular el promedio
titanic.groupby('sex')[['survived']].mean()

promedio de cuantos sobrevivieron por genero divididos por clase

# 1. Agrupar por genero y clase
# 2. Obtener los sobrevivientes
# 3. Calcular el promedio
# 4. Poner el resultado como una tabla (.unstack)
titanic.groupby(['sex', 'class'])['survived'].mean().unstack()

Usando Pivot tables

titanic.pivot_table('survived', index='sex', columns='class')

titanic.pivot_table('survived', index='sex', columns='class', margins=True)

Otro ejemplo mas simple:

data = {'A':['foo','foo','foo','bar','bar','bar'],
     'B':['one','one','two','two','one','one'],
       'C':['x','y','x','y','x','y'],
       'D':[1,3,2,5,4,1]}
df = pd.DataFrame(data)
df

# pivot tables
df.pivot_table(values='D',index=['A', 'B'],columns=['C'])

---

Concatenar, Fusionar y Unir (Concatenating, Merging, Joining)

Hay 3 formas principales de combinar DataFrames: concatenar, fusionar y unir.

# DataFrames de ejemplo para concatenacion
import pandas as pd

df1 = pd.DataFrame({'A': ['A0', 'A1', 'A2', 'A3'],
                        'B': ['B0', 'B1', 'B2', 'B3'],
                        'C': ['C0', 'C1', 'C2', 'C3'],
                        'D': ['D0', 'D1', 'D2', 'D3']},
                        index=[0, 1, 2, 3])

df2 = pd.DataFrame({'A': ['A4', 'A5', 'A6', 'A7'],
                        'B': ['B4', 'B5', 'B6', 'B7'],
                        'C': ['C4', 'C5', 'C6', 'C7'],
                        'D': ['D4', 'D5', 'D6', 'D7']},
                         index=[4, 5, 6, 7]) 

df3 = pd.DataFrame({'A': ['A8', 'A9', 'A10', 'A11'],
                        'B': ['B8', 'B9', 'B10', 'B11'],
                        'C': ['C8', 'C9', 'C10', 'C11'],
                        'D': ['D8', 'D9', 'D10', 'D11']},
                        index=[8, 9, 10, 11])

df1

df2

df3

Concatenacion (Concatenation)

La concatenación básicamente combina DataFrames. Tenga en cuenta que las dimensiones deben coincidir a lo largo del eje con el que se está concatenando.

la concatenacion se hace con dataframes de diferentes indices

Puede usar .concat() y pasar una lista de DataFrames para concatenar juntos:

# Concatenar cada dateframe verticalmente, ya que coinciden los nombres de las columnas
pd.concat([df1,df2,df3])

#concatenar dataframe horizontalmente, como no coinciden los index observar lo que ocurre
pd.concat([df1,df2,df3],axis=1)

Fusion (Merging)

La función merge() le permite fusionar DataFrames juntos utilizando una lógica similar a la combinación de Tablas SQL. Por ejemplo:

# DataFrames de ejemplo para merging
left = pd.DataFrame({'key': ['K0', 'K1', 'K2', 'K3'],
                     'A': ['A0', 'A1', 'A2', 'A3'],
                     'B': ['B0', 'B1', 'B2', 'B3']})
   
right = pd.DataFrame({'key': ['K0', 'K1', 'K2', 'K3'],
                          'C': ['C0', 'C1', 'C2', 'C3'],
                          'D': ['D0', 'D1', 'D2', 'D3']})    

left

right

# how='inner' utilice la intersección de las claves de ambos marcos, similar a una combinación interna de SQL; 
# las keys son comunes
pd.merge(left,right,how='inner',on='key')

Un ejemplo mas complicado:

• Natural join: para mantener solo las filas que coinciden con los marcos de datos, especifique el argumento how = ‘inner’.
• Full outer join: para mantener todas las filas de ambos dataframe, especifique how = ‘OUTER’.
• Left outer join: para incluir todas las filas de su dataframe x y solo aquellas de y que coincidan, especifique how=‘left’.
• Right outer join: para incluir todas las filas de su dataframe y y solo aquellas de x que coincidan, especifique how=‘right’.

left = pd.DataFrame({'key1': ['K0', 'K0', 'K1', 'K2'],
                     'key2': ['K0', 'K1', 'K0', 'K1'],
                        'A': ['A0', 'A1', 'A2', 'A3'],
                        'B': ['B0', 'B1', 'B2', 'B3']})
    
right = pd.DataFrame({'key1': ['K0', 'K1', 'K1', 'K2'],
                               'key2': ['K0', 'K0', 'K0', 'K0'],
                                  'C': ['C0', 'C1', 'C2', 'C3'],
                                  'D': ['D0', 'D1', 'D2', 'D3']})

left

right

# fusionando comparando las mismas claves que tengan comunes
pd.merge(left, right, on=['key1', 'key2'])

# fusionando totalmente las dos tablas con las claves
pd.merge(left, right, how='outer', on=['key1', 'key2'])

# fusionando usando las claves de la tabla right
pd.merge(left, right, how='right', on=['key1', 'key2'])

# fusionando usando las claves de la tabla left
pd.merge(left, right, how='left', on=['key1', 'key2'])

Unir (Joining)

Unir (join) es un método conveniente para combinar las columnas de dos DataFrames potencialmente indexados de forma diferente en un solo DataFrame. Join hace uniones de índices sobre índices o de índices sobre columnas

left = pd.DataFrame({'A': ['A0', 'A1', 'A2'],
                     'B': ['B0', 'B1', 'B2']},
                      index=['K0', 'K1', 'K2']) 

right = pd.DataFrame({'C': ['C0', 'C2', 'C3'],
                    'D': ['D0', 'D2', 'D3']},
                      index=['K0', 'K2', 'K3'])

left

right

# unir el dataframe 'right' a el dataframe 'left'
left.join(right)

# unir el dataframe 'left' a el dataframe 'right'
right.join(left)

# unir el dataframe 'left' a el dataframe 'rigth'
#how = outer
left.join(right, how='outer')

Datos Categoricos

• La busqueda en datos categoricos es mucho mas rapida
• Ocupan Menos memoria que si los datos estan como string
• Se pueden tener datos categoricos Ordinales

Mas informacion de datos categoricos:

https://pandas.pydata.org/pandas-docs/stable/user_guide/categorical.html

Creacion

# Creacion de una serie de datos categoricos
cate = pd.Series(["manzana", "banano", "corozo", "manzana","pera"], dtype="category")
cate

0    manzana
1     banano
2     corozo
3    manzana
4       pera
dtype: category
Categories (4, object): [banano, corozo, manzana, pera]

cate.dtypes

CategoricalDtype(categories=['banano', 'corozo', 'manzana', 'pera'], ordered=False)

cate.describe()

count           5
unique          4
top       manzana
freq            2
dtype: object

# Creando primero los datos y luego convirtiendolos en categoricos
df_cate = pd.DataFrame({"Fruta":["manzana", "banano", "corozo", "manzana","pera"]})
df_cate

# Observar los tipos de datos en el data frame
df_cate.dtypes

Fruta    object
dtype: object

df_cate["Fruta2"] = df_cate["Fruta"].astype('category')
df_cate

# Observar los tipos de datos en el dataframe
df_cate.dtypes

Fruta       object
Fruta2    category
dtype: object

# Crear los datos categoricos desde a declaracion de los datos
df_cate = pd.DataFrame({'A': list('abca'), 'B': list('bccd')}, dtype="category")
df_cate

df_cate.dtypes

A    category
B    category
dtype: object

df_cate.describe()

Categoricos Ordinales

from pandas.api.types import CategoricalDtype

# creacion de dataframe con datos
df_cate = pd.DataFrame({'A': list('abca'), 'B': list('bccd')})
df_cate

df_cate.dtypes

A    object
B    object
dtype: object

# Definicion de los tipos de datos y que estan en orden
df_cate["A"] = df_cate["A"].astype(CategoricalDtype(['a','b','c','d'], ordered=True))
df_cate

df_cate["A"]

0    a
1    b
2    c
3    a
Name: A, dtype: category
Categories (4, object): [a < b < c < d]

# Los datos no tienen que ser strngs para qeu sean categoricos
s = pd.Series([1, 2, 3, 1], dtype="category")
s

0    1
1    2
2    3
3    1
dtype: category
Categories (3, int64): [1, 2, 3]

s = s.cat.set_categories([2, 3, 1], ordered=True)
s

0    1
1    2
2    3
3    1
dtype: category
Categories (3, int64): [2 < 3 < 1]

---

Datos Faltantes (Missing data)

Métodos para Manejar datos faltantes en pandas:

# Declaracion de data frame con algunos datos faltantes
# NaN = Not a Number
df = pd.DataFrame({'A':[1,2,np.nan],
                  'B':[5,np.nan,np.nan],
                  'C':[1,2,3]})
df

Detectar si Faltan datos

# verificar cuales valores son NaN o nulos (Null)
df.isna()

# verificar cuales valores son na
# el metodo .isnull() es igual a .isna()
df.isnull()

# Verificar si hay datos faltantes por columna
df.isnull().any()

A     True
B     True
C    False
dtype: bool

Numero de datos faltantes

Calcular el numero de datos nulos que hay por columna

# Numero de datos faltantes por columna
df.isnull().sum()

A    1
B    2
C    0
dtype: int64

Eliminar datos Faltantes

# Eliminar todas las filas que tengan datos faltantes
df.dropna(axis=0) # cuando son filas no es neceario escribir axis=0

# Eliminar todas las columnas que tengan datos faltantes
df.dropna(axis=1)

# eliminar las filas que tengas 2 o mas valores NaN
df.dropna(thresh=2)

Reemplazar los datos faltantes

# Llenar los datos faltantes con el dato que nos interese
df.fillna(value='FILL VALUE') # llenar los espacios con un string
                              # puede ser una palabra, numero , etc

# Llenar los datos faltantes con el dato que nos interese
df.fillna(value=99) # llenar los espacios con un numero

# Llenar los datos faltantes con el promedio de esa columna
df['A'].fillna(value=df['A'].mean())

0    1.0
1    2.0
2    1.5
Name: A, dtype: float64

# Llenar los datos faltantes con el promedio de cada columna
df.fillna(value=df.mean())

Datos unicos (Unique Values)

import pandas as pd
# crear un dataframe
df = pd.DataFrame({'col1':[1,2,3,4],'col2':[444,555,666,444],'col3':['abc','def','ghi','xyz']})
df.head() # solamente mostrar los primeros elementos del dataframe

# valores unicos de la columna col2
df['col2'].unique()

array([444, 555, 666])

# Numero de valores unicos en el dataframe
df['col2'].nunique()

3

# contar cuanto se repiten cada uno de los valores
df['col2'].value_counts()

444    2
555    1
666    1
Name: col2, dtype: int64

Datos Duplicados

Se puede borrar los registros que son exactamente iguales en todos los valores de las columnas

import pandas as pd

datos = {'name': ['James', 'Jason', 'Rogers', 'Jason'], 'age': [18, 20, 22, 20], 'job': ['Assistant', 'Manager', 'Clerk', 'Manager']}
df_dup = pd.DataFrame(datos)
df_dup

# Metodo para detectar los datos duplicados
# me sirve para ver si existen registros duplicados
df_dup.duplicated()

0    False
1    False
2    False
3     True
dtype: bool

# Contar cuantos datos duplicados existen
df_dup.duplicated().sum()

1

# Para remover los datos duplicados
df_dup.drop_duplicates()

# El metodo drop_duplicates entrega el data frame sin duplicados
# Pero la funcion no es inplace, osea que el dataframe original sigue igual
df_dup

df_dup.drop_duplicates(inplace=True)
df_dup

Duplicados por Columna

Se pueden borrar los valores que se repitan solamente verificando la columna

frame_datos = {'name': ['James', 'Jason', 'Rogers', 'Jason'], 'age': [18, 20, 22, 21], 'job': ['Assistant', 'Manager', 'Clerk', 'Employee']}
df_dup = pd.DataFrame(frame_datos)
df_dup

el valor de jason esta duplicado en la columna name

# recordar que estas funciones no son inplace
df_dup.drop_duplicates(['name'])

Outliers

Una de las formas de eliminar los aoutliers es identificando cual sera el rango en el que queremos nuestros datos y limitar los datos entre ese rango

import seaborn as sns # importar la libreria seaborn
# cargar dataset del titanic
titanic = sns.load_dataset('titanic')
titanic.head()

edad = titanic['age']
edad

0      22.0
1      38.0
2      26.0
3      35.0
4      35.0
5       NaN
6      54.0
7       2.0
8      27.0
9      14.0
10      4.0
11     58.0
12     20.0
13     39.0
14     14.0
15     55.0
16      2.0
17      NaN
18     31.0
19      NaN
20     35.0
21     34.0
22     15.0
23     28.0
24      8.0
25     38.0
26      NaN
27     19.0
28      NaN
29      NaN
       ... 
861    21.0
862    48.0
863     NaN
864    24.0
865    42.0
866    27.0
867    31.0
868     NaN
869     4.0
870    26.0
871    47.0
872    33.0
873    47.0
874    28.0
875    15.0
876    20.0
877    19.0
878     NaN
879    56.0
880    25.0
881    33.0
882    22.0
883    28.0
884    25.0
885    39.0
886    27.0
887    19.0
888     NaN
889    26.0
890    32.0
Name: age, Length: 891, dtype: float64

# Cual es la edad maxima
edad.max()

80.0

# Cual es la edad Minima
edad.min()

0.42

Solo por hacer el ejercicio se delimitaran las edades entre 1 y 70 años

esto se puede hacer con el metodo .clip(lower = Valor mas bajo, upper = valor mas alto)

edad = edad.clip(lower=1,upper = 70)

edad.max()

70.0

edad.min()

1.0

Tablas de Contingencia (two way tables)

# Crear Datos
raw_data = {'regiment': ['Nighthawks', 'Nighthawks', 'Nighthawks', 'Nighthawks', 'Dragoons', 'Dragoons', 'Dragoons', 'Dragoons', 'Scouts', 'Scouts', 'Scouts', 'Scouts'], 
        'company': ['infantry', 'infantry', 'cavalry', 'cavalry', 'infantry', 'infantry', 'cavalry', 'cavalry','infantry', 'infantry', 'cavalry', 'cavalry'], 
        'experience': ['veteran', 'rookie', 'veteran', 'rookie', 'veteran', 'rookie', 'veteran', 'rookie','veteran', 'rookie', 'veteran', 'rookie'],
        'name': ['Miller', 'Jacobson', 'Ali', 'Milner', 'Cooze', 'Jacon', 'Ryaner', 'Sone', 'Sloan', 'Piger', 'Riani', 'Ali'], 
        'preTestScore': [4, 24, 31, 2, 3, 4, 24, 31, 2, 3, 2, 3],
        'postTestScore': [25, 94, 57, 62, 70, 25, 94, 57, 62, 70, 62, 70]}
df = pd.DataFrame(raw_data, columns = ['regiment', 'company', 'experience', 'name', 'preTestScore', 'postTestScore'])
df

# Tabla de contingencia por compañía y regimiento
pd.crosstab(df['regiment'], df['company'], margins=True)

# Tabla de contingencia de compañia y experiencia por regimiento
pd.crosstab([df['company'], df['experience']], df['regiment'],  margins=True)

Metodos y Funciones en Pandas

Todos los metodos de los dataframe de pandas se pueden encontrar en:

http://pandas.pydata.org/pandas-docs/stable/reference/frame.html

import pandas as pd
# crear un dataframe
df = pd.DataFrame({'col1':[1,2,3,4],'col2':[444,555,666,444],
                   'col3':['mama   ','  papa','   HIJO  ','HiJa']})
df.head() # solamente mostrar los primeros elementos del dataframe

Metodos Basicos Pandas

Ejemplos simples de los metodos de los dataframe de pandas

Para informacion completa de los metodos de computacion y estadisticos ver:

http://pandas.pydata.org/pandas-docs/stable/reference/frame.html#computations-descriptive-stats

# Suma total de cada Columna, si es categorico no lo suma
df.sum()

col1                            10
col2                          2109
col3    mama     papa   HIJO  HiJa
dtype: object

# Metodo en una sola columna
df['col1'].sum()

10

# Metodo en varias columnas
df[['col1','col2']].sum()

col1      10
col2    2109
dtype: int64

# Valor Minimo cada Columna
df.min()

col1            1
col2          444
col3       HIJO  
dtype: object

# Valor Maximo cada Columna
df.max()

col1          4
col2        666
col3    mama   
dtype: object

Metodos de Informacion General

# Cargar la base de datos 'mpg' de la libreria seaborn
import seaborn as sns

# los datos se cargan en un dataframe
data = sns.load_dataset('mpg')

data.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 398 entries, 0 to 397
Data columns (total 9 columns):
mpg             398 non-null float64
cylinders       398 non-null int64
displacement    398 non-null float64
horsepower      392 non-null float64
weight          398 non-null int64
acceleration    398 non-null float64
model_year      398 non-null int64
origin          398 non-null object
name            398 non-null object
dtypes: float64(4), int64(3), object(2)
memory usage: 28.1+ KB

data.head()

data.describe() # ver datos estadisticos de las columnas numericas

data.describe(include = 'all') # ver todos los datos incluidos los categoricos

# Descripcion de una sola columna
data['cylinders'].describe()

count    398.000000
mean       5.454774
std        1.701004
min        3.000000
25%        4.000000
50%        4.000000
75%        8.000000
max        8.000000
Name: cylinders, dtype: float64

data['mpg'].describe()

count    398.000000
mean      23.514573
std        7.815984
min        9.000000
25%       17.500000
50%       23.000000
75%       29.000000
max       46.600000
Name: mpg, dtype: float64

data['cylinders'].dtypes

dtype('int64')

Estadistica Descriptiva

Metodos de Estadistica Descriptiva, de medida central, simetria, momentos, etc. para mas informacion: http://pandas.pydata.org/pandas-docs/stable/reference/frame.html#computations-descriptive-stats

Los calculos de las medidas estadisticas se hacen siempre en columnas, es algo predeterminado, si se quiere hacer por filas, se debe especificar dentro de los metodos el parametro axis=1.

Ejemplo:

• Calculo de la media por columnas (predeterminado) = df.mean()
• Calculo de la media por filas = df.mean(axis=1)

Esto funciona con los otros tipos de medidas estadisticas

# Se tomara la columna 'mpg' para realizar los calculos
X = data['mpg']
type(X)

pandas.core.series.Series

Medidas de centralizacion

estas funciones se aplican sobre un dataframe de pandas

Media

# Media Aritmetica
X.mean()

23.514572864321615

# Media aritmetica en un dataframe
data.mean()

mpg               23.514573
cylinders          5.454774
displacement     193.425879
horsepower       104.469388
weight          2970.424623
acceleration      15.568090
model_year        76.010050
dtype: float64

Mediana

# Mediana
X.median()

23.0

# Mediana en un dataframe
data.median()

mpg               23.0
cylinders          4.0
displacement     148.5
horsepower        93.5
weight          2803.5
acceleration      15.5
model_year        76.0
dtype: float64

Maximo y Minimo

# Maximo
X.max()

46.6

# Maximo en un dataframe
data.max()

mpg                         46.6
cylinders                      8
displacement                 455
horsepower                   230
weight                      5140
acceleration                24.8
model_year                    82
origin                       usa
name            vw rabbit custom
dtype: object

# Minimo
X.min()

9.0

# Minimo en un dataframe
data.min()

mpg                                   9
cylinders                             3
displacement                         68
horsepower                           46
weight                             1613
acceleration                          8
model_year                           70
origin                           europe
name            amc ambassador brougham
dtype: object

Moda

# Moda
X.mode()

0    13.0
dtype: float64

# Moda en un dataframe
data.mode()

Cuartiles

# Valores de los cuartiles
X.quantile([0, .25, .5, .75, 1])

0.00     9.0
0.25    17.5
0.50    23.0
0.75    29.0
1.00    46.6
Name: mpg, dtype: float64

# Valores de los cuartiles en un dataframe
data.quantile([0, .25, .5, .75, 1])

Medidas de dispersion

Varianza

# Varianza
X.var() #unbiased Normalized by N-1 by default.

61.089610774274405

# Varianza en un dataframe
data.var()

mpg                 61.089611
cylinders            2.893415
displacement     10872.199152
horsepower        1481.569393
weight          717140.990526
acceleration         7.604848
model_year          13.672443
dtype: float64

Desviacion Estandard

# Desviacion tipica o desviacion estandard
X.std()

7.815984312565782

# Desviacion tipica o desviacion estandard en un dataframe
data.std()

mpg               7.815984
cylinders         1.701004
displacement    104.269838
horsepower       38.491160
weight          846.841774
acceleration      2.757689
model_year        3.697627
dtype: float64

Coeficiente de Variacion

# Coeficiente de Variacion
X.std()/X.mean()

0.3323889554645019

Medidas de Asimetria

Asimetria de Fisher (skewness)

La asimetría es la medida que indica la simetría de la distribución de una variable respecto a la media aritmética, sin necesidad de hacer la representación gráfica. Los coeficientes de asimetría indican si hay el mismo número de elementos a izquierda y derecha de la media.

Existen tres tipos de curva de distribución según su asimetría:

• Asimetría negativa: la cola de la distribución se alarga para valores inferiores a la media.
• Simétrica: hay el mismo número de elementos a izquierda y derecha de la media. En este caso, coinciden la media, la mediana y la moda. La distribución se adapta a la forma de la campana de Gauss, o distribución normal.
• Asimetría positiva: la cola de la distribución se alarga para valores superiores a la media.

#unbiased skew, Normalized by N-1
X.skew() 

0.45706634399491913

#unbiased skew, Normalized by N-1 en un dataframe
data.skew()

mpg             0.457066
cylinders       0.526922
displacement    0.719645
horsepower      1.087326
weight          0.531063
acceleration    0.278777
model_year      0.011535
dtype: float64

Curtosis

Esta medida determina el grado de concentración que presentan los valores en la región central de la distribución. Por medio del Coeficiente de Curtosis, podemos identificar si existe una gran concentración de valores (Leptocúrtica), una concentración normal (Mesocúrtica) ó una baja concentración (Platicúrtica).

# unbiased kurtosis over requested axis using Fisher's definition
X.kurtosis()

-0.5107812652123154

# unbiased kurtosis over requested axis using Fisher's definition
# en un dataframe
data.kurtosis()

mpg            -0.510781
cylinders      -1.376662
displacement   -0.746597
horsepower      0.696947
weight         -0.785529
acceleration    0.419497
model_year     -1.181232
dtype: float64

Covarianza

Entre Series

s1 = pd.Series(np.random.randn(1000))
s2 = pd.Series(np.random.randn(1000))

s1.cov(s2)

-0.028354705528775087

# Numpy
np.cov(s1,s2)

array([[ 1.09020966, -0.02835471],
       [-0.02835471,  1.07417272]])

Dataframe

frame = pd.DataFrame(np.random.randn(1000, 5),columns=['a', 'b', 'c', 'd', 'e'])
frame.head()

frame.cov()

# Con Numpy
np.cov(frame)

array([[ 0.7710721 ,  0.51639576, -0.42821644, ..., -0.23771807,
        -0.63698462,  0.44026319],
       [ 0.51639576,  1.78416315, -0.17363496, ..., -1.00370658,
        -1.14416467,  0.59572484],
       [-0.42821644, -0.17363496,  0.49727435, ...,  0.08767001,
         0.33921621, -0.06352345],
       ...,
       [-0.23771807, -1.00370658,  0.08767001, ...,  0.64880976,
         0.65597959, -0.23257827],
       [-0.63698462, -1.14416467,  0.33921621, ...,  0.65597959,
         0.90660696, -0.45814778],
       [ 0.44026319,  0.59572484, -0.06352345, ..., -0.23257827,
        -0.45814778,  0.46902464]])

Correlacion

Metodos:

• pearson (predeterminado)
• kendall
• spearman

#  Creacion de dataframe con datos aleatorios
frame = pd.DataFrame(np.random.randn(1000, 5), columns=['a', 'b', 'c', 'd', 'e'])
frame.head()                     

Entre Series

frame['a'].corr(frame['b']) # Pearson que es el predeterminado

-0.052592953776030495

frame['a'].corr(frame['b'], method='spearman') # Metodo spearman

-0.04775690375690376

frame['a'].corr(frame['b'], method='kendall') # Metodo Kendall

-0.03213613613613614

# Con Numpy se realiza el coefficiente de Pearson
# realiza la correlacion entre dos vectores
np.corrcoef(frame['a'],frame['b'])

array([[ 1.        , -0.05259295],
       [-0.05259295,  1.        ]])

Dataframe

frame.corr()

# con Numpy
np.corrcoef(frame)

array([[ 1.        , -0.58501996,  0.55616525, ...,  0.26806025,
        -0.35940809, -0.00452158],
       [-0.58501996,  1.        , -0.3400534 , ...,  0.11257458,
        -0.37590609, -0.58877942],
       [ 0.55616525, -0.3400534 ,  1.        , ...,  0.70442968,
         0.13326316, -0.19220235],
       ...,
       [ 0.26806025,  0.11257458,  0.70442968, ...,  1.        ,
         0.19271014, -0.79265039],
       [-0.35940809, -0.37590609,  0.13326316, ...,  0.19271014,
         1.        ,  0.14871875],
       [-0.00452158, -0.58877942, -0.19220235, ..., -0.79265039,
         0.14871875,  1.        ]])

Funciones Agregadas

Para aplicar una o mas funciones en cada columna de los dataframe

df.agg(['sum', 'min'])

# Aplicar los metodos en columnas especificas
df[['col1','col2']].agg(['sum', 'min'])

Aplicando Funciones a cada elemento

#definicion de funcion
def times2(x):
    return x*2

# es mas o menos lo que hace la funcion map
# aplicar la funcion times2 a cada elemento de la col1 de dataframe df
df['col1'].apply(times2)

0    2
1    4
2    6
3    8
Name: col1, dtype: int64

df['col3'].apply(len) #longitud de cada uno de los datos de la col3

0    7
1    6
2    9
3    4
Name: col3, dtype: int64

df['col1'].sum() #sumatoria total de los elementos de la col1

10

(Sorting) Ordenar un DataFrame:

df

# ordenar el dataframe de menor a mayor basado en col2
df.sort_values(by='col2') #inplace=False por default

df.sort_values(by='col2',ascending=False)

Metodos de strings

Los metodos de los strings se pueden usar en pandas de forma vectorizada

https://pandas.pydata.org/pandas-docs/stable/getting_started/basics.html#vectorized-string-methods

Los metodos vectorizados de los strings son:

https://pandas.pydata.org/pandas-docs/stable/user_guide/text.html#text-string-methods

Nota: Recordar que la mayoria de los metodos NO son inplace

df

# Estos Metodos solo funcionan por columna (Series)
# se puede verificar el error
#df.str.lower()

Algunos ejemplos de metodos en strings en las columnas

# convertir strings en minuscula
df['col3'].str.lower()

0      mama   
1         papa
2       hijo  
3         hija
Name: col3, dtype: object

# convertir strings en Mayuscula
df['col3'].str.upper()

0      MAMA   
1         PAPA
2       HIJO  
3         HIJA
Name: col3, dtype: object

# Eliminar los espacios de los strings
df['col3'].str.strip()

0    mama
1    papa
2    HIJO
3    HiJa
Name: col3, dtype: object

Transformacion de Variables

• Crear variables Dummy: convertir de categoría a númerica
• Discretización o Binning: convertir de número a categoría

Columnas Dummy

Convertir variables categoricas a numericas

# crear datos categoricos
raw_data = {'first_name': ['Jason', 'Molly', 'Tina', 'Jake', 'Amy'], 
        'last_name': ['Miller', 'Jacobson', 'Ali', 'Milner', 'Cooze'], 
        'sex': ['male', 'female', 'male', 'female', 'female']}
df = pd.DataFrame(raw_data, columns = ['first_name', 'last_name', 'sex'])
df

# Crear un set de variables dummy para la columna sex
df_sex = pd.get_dummies(df['sex'])
df_sex

# unir los dos dataframes
df_new = df.join(df_sex)
df_new

Discretización o Binning

Conversion de Numerica a Categorica

https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.cut.html

# dividir los datos en 3 rangos iguales (categorias)

pd.cut(np.array([3.5, 2.8, 1, 5, 3, 4, 0, 4.4, 2, 3]), 3)

[(3.333, 5.0], (1.667, 3.333], (-0.005, 1.667], (3.333, 5.0], (1.667, 3.333], (3.333, 5.0], (-0.005, 1.667], (3.333, 5.0], (1.667, 3.333], (1.667, 3.333]]
Categories (3, interval[float64]): [(-0.005, 1.667] < (1.667, 3.333] < (3.333, 5.0]]

# Asignar etiquetas ordenadas
pd.cut(np.array([3.5, 2.8, 1, 5, 3, 4,0, 4.4, 2, 3]),
       3, labels=["Malo", "Regular", "Bien"])

[Bien, Regular, Malo, Bien, Regular, Bien, Malo, Bien, Regular, Regular]
Categories (3, object): [Malo < Regular < Bien]

pd.cut(np.array([2, 4 , 10 , 35 , 25 , 60 , 23, 14]),
       3, labels=["Niño", "Adolescente", "Adulto"])

[Niño, Niño, Niño, Adolescente, Adolescente, Adulto, Adolescente, Niño]
Categories (3, object): [Niño < Adolescente < Adulto]

---

Leer y guardar Datos (Data Input and Output)

Pandas puede leer una variedad de tipos de archivos usando sus métodos pd.read_ mas informacion

• CSV
• Excel
• Json
• Html
• SQL

CSV File (comma-separated values)

CSV Input

# Leer archivos separados por comas, extension .csv
df1 = pd.read_csv('./Data/supermarkets.csv')
df1

# dimensiones del dataframe
df1.shape

(6, 7)

# conocer los tipos de datos de cada columna
df1.dtypes

ID            int64
Address      object
City         object
State        object
Country      object
Name         object
Employees     int64
dtype: object

# Tambien se puede cambiar el valor de la columna index
# definir la columna ID como el index
df1.set_index("ID",inplace=True) # se debe especificar que sea inplace
df1

# hare un cambio y luego lo grabare
# multiplicar cada elemento de la columna employees por 2
df1['Employees']= df1['Employees'].apply(lambda x: x*2)
df1

CSV Output

# Grabar el dataframe como archivo separado por comas
df1.to_csv('./Data/example_out.csv',index=False)

Archivo de texto separado por comas

# Leer archivos separados por comas, extension .txt o sin extension
df1 = pd.read_csv("./Data/supermarkets-commas.txt")
df1

Archivo de texto separado por otro caracter

# este archivo los valores estan separados por ;
df1 = pd.read_csv("./Data/supermarkets-semi-colons.txt",sep=';')
df1

Excel

Pandas puede leer y escribir archivos de Excel, tenga en cuenta que esto solo importa datos. No fórmulas o imágenes, que tengan imágenes o macros pueden hacer que este método read_excel se bloquee.

Excel Input

# leer un archivo de excel
df2 = pd.read_excel("./Data/supermarkets.xlsx",sheet_name=0) #leer la primera hoja del archivo
df2

# tambien podemos cambiar la columna del index
df2.set_index('ID')
df2

Excel Output

# sumar cada elemento del data frame por 4
df2['Number of Employees'] = df2['Number of Employees'].apply(lambda x: x+4)
df2

df2.to_excel('./Data/Excel_Sample_out.xlsx',sheet_name='Hoja1')

JSON

JSON (JavaScript Object Notation - Notación de Objetos de JavaScript) es un formato ligero de intercambio de datos. Leerlo y escribirlo es simple para humanos, mientras que para las máquinas es simple interpretarlo y generarlo.

Json Input

# los archivos pueden estar en un link de internet
df4 = pd.read_json("http://pythonhow.com/supermarkets.json")
df4

Json output

#Para grabar
df4.to_json("./Data/Salida.json")

WEKA (arff)

from scipy.io import arff # libreria para importar archivos de weka
# principalmente importa datos numericos
data = arff.loadarff('./Data/yeast-train.arff')
df5 = pd.DataFrame(data[0])
df5.head()

HTML

Se debe instalar htmllib5,lxml y BeautifulSoup4. En la terminal escriba

conda install lxml
conda install html5lib
conda install BeautifulSoup4

Luego reinicie el Jupyter Notebook. (o use pip install si no esta usando la distribucion de Anaconda)

Pandas puede leer tablas de html

La función pandas read_html leerá las tablas de una página web y devolverá una lista de objetos DataFrame:

data = pd.read_html('http://www.fdic.gov/bank/individual/failed/banklist.html')

data[0]

---

SQL

El módulo pandas.io.sql proporciona una colección de contenedores de consultas para facilitar la recuperación de datos y reducir la dependencia de la API específica de DB. La abstracción de la base de datos es proporcionada por SQLAlchemy si está instalado. Además, necesitará una biblioteca de controladores para su base de datos. Ejemplos de tales controladores son psycopg2 para PostgreSQL o pymysql para MySQL. Para SQLite esto está incluido en la biblioteca estándar de Python por defecto. Puede encontrar una descripción general de los controladores admitidos para cada lenguaje SQL en los documentos de SQLAlchemy.

Vea también algunos ejemplos de libros para algunas estrategias avanzadas.

las funciones claves son:

• read_sql_table(table_name, con[, schema, …])
  • Read SQL database table into a DataFrame.
• read_sql_query(sql, con[, index_col, …])
  • Read SQL query into a DataFrame.
• read_sql(sql, con[, index_col, …])
  • Read SQL query or database table into a DataFrame.
• DataFrame.to_sql(name, con[, flavor, …])
  • Write records stored in a DataFrame to a SQL database.

# librerias para crear un proceso de sql sencillo
from sqlalchemy import create_engine

# crear un proceso en memoria
engine = create_engine('sqlite:///:memory:')

df4.to_sql('data', engine) # grabar el dataframe en formato sql

sql_df = pd.read_sql('data',con=engine) # definir la conexion

sql_df

Referencias

• Web Pandas
• 10 Minutes to Pandas
• Tutoriales oficiales de Pandas
• Pandas Basic cheat sheet
• Pandas cheat sheet
• Pandas Importing data cheat sheet
• Pandas vs R, SQL SAS y otras herramientas, Comparacion de comandos

Phd. Jose R. Zapata

• https://joserzapata.github.io/
• https://twitter.com/joserzapata