#!pip install --upgrade 'polars[pandas,pyarrow,xlsx2csv]'

import polars as pl # Importacion estandar de la libreria Polars
import numpy as np # Importacion estandar de la libreria NumPy

pl.__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

# Convertir una lista en series usando el método pl.Series
# observe que se crean los nombres con las posiciones de cada elemento
pl.Series(values=my_list)

# Convertir una lista en series usando el método pl.Series
# se puede ingresar el nombre de la serie
pl.Series(name= "numeros" ,values=my_list)

# No es necesario ingresar la palabra de 'values =''  en el argumento
# Convertir una lista en series usando el método pl.Series
# se puede ingresar el nombre de la serie
pl.Series(my_list)

# Convertir un arreglo en series usando el método pl.Series
pl.Series(arr)

# Convertir un arreglo en series indicando también el nombre
pl.Series("numpy",arr)

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

# Creacion de una serie con sus labels o indices
ser1 = pl.Series([1,2,3,4])

ser1

# Creacion de una serie con sus labels o indices
ser2 = pl.Series([1,2,5,4])

ser2

# La busqueda en una serie es igual como en una lista, usando el numero de su posicion
ser1[0]

ser2[3]

# SOn operaciones 1 a 1
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

# Crear un dataframe con números aleatorios de 4 Columnas y 5 Filas
# Esto evita tener que escribir repetidamente las comas

df = pl.DataFrame(
    {
        "W": randn(6),
        "X": randn(6),
        "Y": randn(6),
        "Z": randn(6)
    }
)

df

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

df.collect_schema()

# solo ver los 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(3)

df.tail(2)

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 = df.with_columns((df["W"] + df["Y"]).alias("new"))
df

df.drop('new')

# 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 debe grabar el resultado

df = df.drop('new') # Elimina la columna new
df

df.columns # nombres de las columnas

df["Z"] # se selecciona todos los valores de la Columna 'Z'

df[:,2] # Se seleccionan todos los valores de la Columna con indice 2
# recordar que los index empiezan en cero

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

# Mediante posicion y etiquetas
# se selecciona un subconjunto de datos que estan entre
# filas = 0, 1   Cols= W, Y
df[[0,1],['W','Y']]

df[[1,0],['Y','W']]

df

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

df.filter(pl.col('W') > 0) # pl.col('W') > 0 crea la condición booleana para la columna W.

# Seleccionar las filas donde 'W' sea mayor que cero
# y también donde 'Y' sea mayor que 0.5

df.filter((pl.col('W') > 0) & (pl.col('Y') > 0.5))

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

df.filter((pl.col('W') > 0))['Y']

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

df.filter((pl.col('W') > 0))[['Y','Z']]

# Seleccionar las filas donde 'W' sea mayor que cero
# y también donde 'Y' sea mayor que 0.5

df.filter((pl.col('W') > 0) & (pl.col('Y') > 0.5))

df

# Crear columna indice con valores por defecto desde 0,1...n index
df = df.with_row_index()
df

import polars as pl
# 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 = pl.DataFrame(data)
df

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

by_comp = df.group_by("Company")

# Promedio de todas las columnas por company
by_comp.mean()

# Promedio de ventas por company, es bueno indicar las columnas numericas
# Para que tenga sentido
by_comp.mean()[["Company","Sales"]]

# agrupar por compañia y calcular el promedio por cada una
df.group_by('Company').mean()[["Company","Sales"]]

# agrupar por compañia y calcular la desviacion estandard
by_comp.agg(pl.col('Sales').std())

# agrupar por compañia y calcular el minimo
by_comp.min()[["Company","Sales"]]

# agrupar por compañia y calcular el maximo
by_comp.max()[["Company","Sales"]]

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

# Para Generar estadísticas descriptivas que resuman la tendencia central,
# la dispersión y la forma de la distribución de un conjunto de datos,
# se pueden agrupar los calculos ccon el metodo .agg

by_comp.agg([
    pl.col("Sales").mean().alias("mean"),
    pl.col("Sales").std().alias("std"),
    pl.col("Sales").min().alias("min"),
    pl.col("Sales").max().alias("max"),
    pl.col("Sales").median().alias("median"),
    pl.col("Sales").count().alias("count")
])

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

type(titanic)

# convertir dataframe de pandas a polars
titanic = pl.from_pandas(titanic)
type(titanic)

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

# 1. Agrupar por genero y clase
# 2. Calcular el promedio
# 3. Obtener los sobrevivientes
titanic.group_by(['sex', 'class']).mean()['sex', 'class','survived']

# Agrupar por 'sex' y 'class', calcular la media de 'survived' y hacer un pivot
grouped = titanic.group_by(['sex', 'class']).agg(
    pl.col('survived').mean()
)

# Crear una tabla dinámica (pivot table)
pivot_table = grouped.pivot(
    values='survived',
    index='sex',
    on='class'
)

pivot_table

# DataFrames de ejemplo para concatenación
import polars as pl

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

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

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

df1

df2

df3

# Concatenar cada dataframe verticalmente,
# ya que coinciden los nombres de las columnas

pl.concat([df1,df2,df3], how="vertical")

df_h1 = pl.DataFrame({"l1": [1, 2], "l2": [3, 4]})
df_h2 = pl.DataFrame({"r1": [5, 6], "r2": [7, 8], "r3": [9, 10]})
pl.concat([df_h1, df_h2], how="horizontal")

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

right = pl.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

left.join(right, on='Producto', how='inner')

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

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

left

right

# fusionando comparando las mismas claves que tengan comunes
left.join(right, on='Producto')

# fusionando totalmente las dos tablas con las claves
left.join(right, on='Producto', how='full')

# fusionando usando las claves de la tabla right
left.join(right, on='Producto', how='right')

# fusionando usando las claves de la tabla left
left.join(right, on='Producto', how='left')

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

cate.dtype

cate.describe()

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

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

df_cate = df_cate.with_columns(
    pl.col("Fruta").cast(pl.Categorical).alias("Fruta2")
)
df_cate

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

# Schema de los datos
df_cate.schema

# Crear los datos categoricos desde a declaracion de los datos
df_cate = pl.DataFrame({
    'A': pl.Series(list('abca')).cast(pl.Categorical),
    'B': pl.Series(list('bccd')).cast(pl.Categorical)
})
df_cate

df_cate.dtypes

df_cate.describe()

# Crear los datos categoricos desde a declaracion de los datos
df_cate = pl.DataFrame({
    'A': pl.Series(list('abca')).cast(pl.Categorical),
    'B': pl.Series(list('bccd')).cast(pl.Categorical)
})
df_cate

df_cate.dtypes

# definición de los tipos de datos y que estan en orden
my_order = ["a", "b", "c", "d"]

df_cate = df_cate.with_columns(
    [pl.col("A").cast(pl.Enum(my_order))],
)
df_cate

df_cate.dtypes

# definición de los tipos de datos y con orden propio
my_order = ["d", "b", "a", "c"]

df_cate = df_cate.with_columns(
    [pl.col("B").cast(pl.Enum(my_order))],
)
df_cate

df_cate.dtypes

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

# Convertir dataframe pandas a Polars
titanic = pl.from_pandas(titanic)

titanic.sample(5)

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

# 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 = titanic.with_columns([
    pl.col(col).cast(pl.Categorical) for col in cols_categoricas_nom
])

# 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.schema

cols_categoricas_ord = ["pclass", "deck"]

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

# Convertir la columna 'pclass' en categórica con un orden específico
titanic = titanic.with_columns(
    pl.col("pclass").cast(pl.Utf8).cast(pl.Enum(['3', '2', '1']))
)

# Convertir la columna 'deck' en categórica con un orden específico
titanic = titanic.with_columns(
    pl.col("deck").cast(pl.Enum(list("ABCDEFG")))
)

titanic.schema

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

columnas_bool = ["alone", "survived"]

titanic = titanic.with_columns([
    pl.col(col).cast(pl.Boolean) for col in columnas_bool
])

titanic.schema

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

# verificar cuales valores son NaN o nulos (Null)
# Verificar cuáles valores son nulos en todas las columnas
df.select([
    pl.col(col).is_null().alias(col) for col in df.columns
])

# Verificar si hay datos faltantes por columna
df.select([
    pl.col(col).is_null().any().alias(col) for col in df.columns
])

# Numero de datos faltantes por columna
df.null_count()

df

# Eliminar todas las columnas que tengan todos los datos faltantes
# en este caso la columna D
df = df[[s.name for s in df if not (s.null_count() == df.height)]]
df

# Eliminar todas las filas que tengan datos faltantes
df.drop_nulls()

# Llenar los datos faltantes con el dato que nos interese
df.fill_null("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.fill_null(value=99) # llenar los espacios con un numero

# Llenar los datos faltantes con el promedio de esa columna
df.with_columns(
    pl.col("A").fill_null(pl.col("A").mean())
)

# Llenar los datos faltantes con el promedio de cada columna
df.with_columns([
    pl.col(col).fill_null(pl.col(col).mean()) for col in df.columns
])

# Crear un DataFrame
df = pl.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'].n_unique()

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

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

# método para detectar los datos duplicados
# me sirve para ver si existen registros duplicados
df_dup.is_duplicated()

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

# Para remover los datos duplicados
df_dup.unique()

# 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 = df_dup.unique(maintain_order=True)
df_dup

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

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

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

# Convertir dataframe pandas a Polars
titanic = pl.from_pandas(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_bound=1, upper_bound=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 = pl.DataFrame(raw_data)
df

# Tabla de contingencia por compañía y regimiento
df.group_by(['regiment', 'company']).len().pivot(index='regiment', on='company', values='len')

# Tabla de contingencia de compañia y experiencia por regimiento

(df.group_by(['regiment','company', 'experience'])
    .len().pivot(index=['company', 'experience'], on='regiment', values='len'))

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

df.with_columns(
    pl.col('col1')*2 + 4
    )

#definición de función
def mult_suma(x: float)->float:
  """ Multiplica un número por 2 y le suma 4
  Args:
    x (float): número a operar
  Returns:
    (float): x*2 + 4

  """
  return x*2 + 4

# evitar usar esta solucion
df.with_columns(
    pl.col('col1').map_elements(mult_suma, return_dtype=pl.Float64)
    )

df.with_columns(
    pl.col('col4') | True   # Operador or
    )

df.with_columns(
    pl.col('col4') & False # operador and
    )

df.with_columns(
    pl.col('col3') == '  papa' # tiene dos espacios antes de la palabra papa
    )

df.with_columns(
    pl.col('col3') != '  papa' # tiene dos espacios antes de la palabra papa
    )

df.with_columns(
    pl.col('col1') > 3 # Mayor que
    )

df.with_columns(
    (pl.col('col1') >= 3).alias("comparacion") # Mayor o  igual que
    )
# metodo .alias() guarda los resultados en una nueva columna

df.with_columns(
    pl.col('col1') < 3 # Menor que
    )

df.with_columns(
    pl.col('col1') <= 3 # Menor o igual que
    )

df.with_columns(
    ((3*pl.col('col1') + pl.col('col2'))*2/27).alias('Resultado')
    )