PANDAS - Manipulacion de Datos con Python

pip install pandas

conda install pandas

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

# 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

# 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)

# 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)

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

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

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

# 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)

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

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

ser1

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

ser2

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

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

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

# 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()

# 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

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

# 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()

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

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

df.head()

df.tail()

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

# 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']] 

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

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

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

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

df

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

df.columns # nombres de las columnas

df.index # nombres de los 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'

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

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

# 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']]

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']

# 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']]

# 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

# 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']

# 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']]

# 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')

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

# 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

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

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

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

by_comp = df.groupby("Company")

# Promedio de ventas por company
by_comp.mean()

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

# 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']

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

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

# 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()

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

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

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'])

# 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

# 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)

# 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')

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'])

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')

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

cate.dtypes

cate.describe()

# 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

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

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

# 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

df_cate.describe()

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

# 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"]

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

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

# 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

# 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()

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

# 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)

# 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())

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

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()

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

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

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()

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

# 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

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

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

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

edad = titanic['age']
edad

# Cual es la edad maxima
edad.max()

# Cual es la edad Minima
edad.min()

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

edad.max()

edad.min()

# 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)

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

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

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

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

# Valor Minimo cada Columna
df.min()

# Valor Maximo cada Columna
df.max()

# 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()

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()

data['mpg'].describe()

data['cylinders'].dtypes

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