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

pd.__version__

# Crear diferentes tipos de datos
labels = ['a','b','c'] # lista de etiquetas
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 método 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 método 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 método pd.Series
pd.Series(arr)

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

# Convertir un diccionario en series usando el método 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', 'Alemania','Italia', 'Japon'])

ser1

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

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

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

# Importar la función de NumPy para crear arreglos de números 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 F'.split()

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

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

df

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

# información general de los datos de cada columna
# 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 información de las columnas categoricas

df.head()

df.tail()

df.sample(3)

# 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
# operación vectorizada
df['new'] = df['W'] + df['Y']
df

df.drop('new',axis='columns')

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

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

df.drop('new', axis='columns', inplace=True) # Forma 2
df

df

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

df

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

df.columns # nombres de las columnas

df.index # nombres de los indices

# la función 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 operación 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 también 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 también 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 FL'.split() # crear una lista con strings
newind

# Agregar la lista creada 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 función 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','GOOG','MSFT','FB'],
       'Person':['Sam','Charlie','Amy','Vanessa','Carl','Sarah','John','Randy','David'],
       'Sales':[200,120,340,124,243,350,275,400,180]}
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(numeric_only=True)

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

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

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

# 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], axis='index')

#concatenar dataframe horizontalmente,
# como no coinciden los index observar lo que ocurre

pd.concat([df1,df2,df3], axis='columns')

# DataFrames de ejemplo para merging
left = pd.DataFrame({
    'Producto': ['Arepas', 'Banano', 'Cafe'],
    'Tienda': [1, 2, 1],
    'Ventas': [100, 200, 50]
})

right = pd.DataFrame({
    'Producto': ['Arepas', 'Banano', 'Cafe'],
    'Tienda': [1, 2, 1],
    'Inventario': [50, 100, 75]
})

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

left = pd.DataFrame({
    'Producto': ['Arepas', 'Leche', 'Cafe'],
    'Tienda': [1, 2, 1],
    'Ventas': [100, 200, 50]
})

right = pd.DataFrame({
    'Producto': ['Arepas', 'Banano', 'Cafe'],
    'Tienda': [1, 2, 1],
    'Inventario': [50, 100, 75]
})

left

right

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

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

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

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

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

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

df_cate.dtypes

# definición de los tipos de datos y que estan en orden
df_cate["A"] = pd.Categorical(df_cate['A'],
                              categories=['a','b','c','d'],
                              ordered=True)
df_cate

df_cate["A"]

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

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

import seaborn as sns # importar la libreria seaborn
titanic = sns.load_dataset('titanic')
titanic.info()

titanic.sample(5)

# convertir la columna sex, embarked, who, embark_town en categoricas
cols_categoricas_nom = ["sex", "embarked", "who", "embark_town"]

# ver los datos unicos de las columnas_categoricas_nom
for columna in cols_categoricas_nom:
  print(f"Valores únicos en {columna}: {titanic[columna].unique()}")

titanic[cols_categoricas_nom] = titanic[cols_categoricas_nom].astype("category")

# ver los datos unicos de las columnas_categoricas_nom
for columna in cols_categoricas_nom:
  print(f"Valores únicos en {columna}: {titanic[columna].unique()}")

cols_categoricas_ord = ["pclass", "deck"]

for columna in cols_categoricas_ord:
  print(f"Valores únicos en {columna}: {titanic[columna].unique()}")

titanic["pclass"] = pd.Categorical(titanic["pclass"],
                                   categories=[3, 2, 1],
                                   ordered=True)
titanic["deck"] = pd.Categorical(titanic["deck"],
                                 categories=list("ABCDEFG"),
                                 ordered=True)

for columna in cols_categoricas_ord:
  print(f"Valores únicos en {columna}: {titanic[columna].unique()}")

columnas_bool = ["alive", "alone", "survived"]

titanic[columnas_bool] = titanic[columnas_bool].astype("bool")

titanic.info()

# 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 si hay datos faltantes por columna
df.isna().any()

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

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

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

# 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='Llenar Valores') # 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 = {'nombre': ['Jaime', 'Juan', 'Roberto', 'Juan'],
         'edad': [18, 20, 22, 20],
         'trabajo': ['Asistente', 'Manager', 'Cientifico', 'Manager']}
df_dup = pd.DataFrame(datos)
df_dup

# método 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 método drop_duplicates entrega el data frame sin duplicados
# Pero la función no es inplace, osea que el dataframe original sigue igual
df_dup

df_dup.drop_duplicates(inplace=True)
df_dup

frame_datos = {'nombre': ['Jaime', 'Juan', 'Roberto', 'Juan'],
               'edad': [18, 20, 22, 21],
              'trabajo': ['Asistente', 'Manager', 'Cientifico', 'Profesor']}
df_dup = pd.DataFrame(frame_datos)
df_dup

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

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

# método en una sola columna
df['col1'].sum()

# método 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