Por Jose R. Zapata

Ultima actualizacion: 2/Noviembre/2024 - Pandas 2.2.2

Pandas es una herramienta de manipulación de datos de alto nivel desarrollada por Wes McKinney. En su inicio es construido sobre Numpy y ahora compatible con Arrow 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). 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, parquet y HDF5 entre otros
• 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 2 tipos básicos de objetos todos ellos basados a su vez en Numpy y ahora en Arrow:

• 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

Pandas con librerias para leer archivos de excel

pip install "pandas[excel]"

Pandas para leer archivos de Arrow (Parquet)

pip install "pandas[pyarrow]"

Para ver otras opciones ir al siguiente link otras instalaciones de pandas

Importando Pandas

La libreria Pandas se importa de la siguiente manera

import numpy as np  # Importación estándar de la librería NumPy
import pandas as pd  # Importación estándar de la librería Pandas

pd.__version__

'2.2.2'

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 método pd.Series:

# 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 lista de valores en arreglo NumPy
d = {"a": 10, "b": 20, "c": 30}  # Creación de un diccionario

Desde Listas

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

0    10
1    20
2    30
dtype: int64

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

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 método pd.Series
pd.Series(arr)

0    10
1    20
2    30
dtype: int64

# Convertir un arreglo en series indicando también 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 método pd.Series
# Como el diccionario ya tiene clave entonces se le asigna como valor de la posición
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:

# Creación de una serie con sus labels o indices
ser1 = pd.Series([1, 2, 3, 4], index=["USA", "Alemania", "Italia", "Japon"])

ser1

USA         1
Alemania    2
Italia      3
Japon       4
dtype: int64

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

ser2

USA         1
Alemania    2
Colombia    5
Japon       4
dtype: int64

# La búsqueda en una serie es igual como en un diccionario
ser1["USA"]

1

# La búsqueda en una serie es igual como en un diccionario
ser2["Colombia"]

5

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

# Observe los resultados de los países que solo están en una serie y no en las dos
ser1 + ser2

Alemania    4.0
Colombia    NaN
Italia      NaN
Japon       8.0
USA         2.0
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 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 rápida de crear una lista de python desde strings
"A B C D E F".split()

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

# Crear un dataframe con números aleatorios de 4 Columnas y 5 Filas
# Crear listas rápidamente 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

Descripcion general del dataframe

Numero de Filas y Columnas

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

(6, 4)

información General de los datos

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

<class 'pandas.core.frame.DataFrame'>
Index: 6 entries, A to F
Data columns (total 4 columns):
 #   Column  Non-Null Count  Dtype
---  ------  --------------  -----
 0   W       6 non-null      float64
 1   X       6 non-null      float64
 2   Y       6 non-null      float64
 3   Z       6 non-null      float64
dtypes: float64(4)
memory usage: 240.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 método .describe() de los dataframes presenta un resumen de la estadistica descriptiva general de las columnas numericas del dataframe, presenta la información de:

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

df.describe()  # No muestra la información de las columnas categóricas

Ver Primeros elementos del dataframe

df.head()

Ver Ultimos elementos del dataframe

df.tail()

Ver elementos aleatorios del dataframe

df.sample(3)

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
F    0.302665
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
# operación vectorial
df["new"] = df["W"] + df["Y"]
df

Eliminando Columnas

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

También se puede sacar filas de esta manera:

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

df

# Otra manera de borrar las columnas es
del df["X"]  # Esta función 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', 'F'], 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 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'

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

O basado en la posición (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 están 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 una serie con booleans
# según si se cumple o no la condición
df["W"] > 0

A     True
B     True
C    False
D     True
E     True
F     True
Name: W, dtype: bool

# seleccionar todas las filas del dataframe 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
F   -1.706086
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 también donde 'Y' sea mayor que 0.5
limite_x = 0
limite_y = 0.5
df[(df["W"] > limite_x) & (df["Y"] > limite_y)]

.query() Busqueda condicional

Los terminos de busqueda condicional o filtros se entregan al método 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
F   -1.706086
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 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")

Cambio de columna de Indexacion

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

df

Se puede reiniciar el indice con numeros consecutivos

df.reset_index()  # reset el indice

# el index anterior se convierte en una columna

Se puede Redefinir el indice con los valores de otra columna

# Es importante tener valores que no sean duplicados
df["States"] = ["CA", "NY", "WY", "OR", "CO", "FL"]
df

# Redefinir la columna states como el indice
df = df.set_index("States", drop=True)
df

Groupby (Agrupacion por filas)

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

# 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],
}
# 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 0x724ca5feb6d0>

utilizar los métodos agregados del objeto:

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

Más ejemplos de métodos agregados:

# agrupar por compañía y calcular la desviación estándar
df.groupby("Company").std(numeric_only=True)

# agrupar por compañía y calcular el mínimo
df.groupby("Company").min()

# agrupar por compañía y calcular el máximo
df.groupby("Company").max()

# agrupar por compañía y sumar los elementos que hay excluyendo los NaN
df.groupby("Company").count()

# Una de las funciones mas usadas para descripción estadística 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
df.groupby("Company").describe()

# Una de las funciones mas usadas para descripción estadística 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 descripción
df.groupby("Company").describe().transpose()

# Descripción estadística de los datos de la compañía GOOG
df.groupby("Company").describe().transpose()["GOOG"]

Sales  count      3.000000
       mean     198.333333
       std       77.513440
       min      120.000000
       25%      160.000000
       50%      200.000000
       75%      237.500000
       max      275.000000
Name: GOOG, dtype: float64

Pivot Tables

La funciónlidad “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 librería 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"], observed=True)["survived"].mean().unstack()

Usando Pivot tables

titanic.pivot_table("survived", index="sex", columns="class", observed=True)

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

Concatenar, Fusionar (Concatenating y Merging)

Las formas principales de combinar DataFrames: concatenar y fusionar

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

Concatenación (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 Concatenación se hace con dataframes de diferentes indices

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

# Concatenar cada dataframe 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")

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

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(
    {
        "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"])

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 información de datos categoricos:

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

Creacion

# Creación de una serie de datos categóricos
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, categories_dtype=object)

cate.describe()

count           5
unique          4
top       manzana
freq            2
dtype: object

# Creando primero los datos y luego convirtiéndolos en categóricos
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 categóricos desde a declaración 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

# creación 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

# definición de los tipos de datos y que están en orden
df_cate["A"] = pd.Categorical(
    df_cate["A"], categories=["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 strings para que sean categóricos
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]

Correcion de tipos de datos (Casting)

Cuando se trabaja con datos, es posible que se encuentre con un DataFrame donde el tipo de datos de una columna no es la correcta. los tipos de datos son principalmente: numericos, categoricos nominales, categoricos ordinales, booleanos, fechas y tiempos, texto.

Se debe convertir los tipos de datos para que sean apropiados para el tipo de datos que representan. Por ejemplo, es posible que desee convertir una columna de strings que representan números en números enteros o flotantes. O puede tener una columna de números que representan fechas, pero que pandas no reconoce como fechas.

Nota: al convertir los datos a su forma correcta, normalmente hace que los DataFrames sean mucho más pequeños en la memoria, lo que los hace más eficientes de usar.

import seaborn as sns  # importar la librería seaborn

titanic = sns.load_dataset("titanic")
titanic.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 891 entries, 0 to 890
Data columns (total 15 columns):
 #   Column       Non-Null Count  Dtype
---  ------       --------------  -----
 0   survived     891 non-null    int64
 1   pclass       891 non-null    int64
 2   sex          891 non-null    object
 3   age          714 non-null    float64
 4   sibsp        891 non-null    int64
 5   parch        891 non-null    int64
 6   fare         891 non-null    float64
 7   embarked     889 non-null    object
 8   class        891 non-null    category
 9   who          891 non-null    object
 10  adult_male   891 non-null    bool
 11  deck         203 non-null    category
 12  embark_town  889 non-null    object
 13  alive        891 non-null    object
 14  alone        891 non-null    bool
dtypes: bool(2), category(2), float64(2), int64(4), object(5)
memory usage: 80.7+ KB

titanic.sample(5)

Casting variables Categoricas nominales

# convertir la columna sex, embarked, who, embark_town en categóricas
cols_categoricas_nom = ["sex", "embarked", "who", "embark_town"]

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

Valores únicos en sex: ['male' 'female']
Valores únicos en embarked: ['S' 'C' 'Q' nan]
Valores únicos en who: ['man' 'woman' 'child']
Valores únicos en embark_town: ['Southampton' 'Cherbourg' 'Queenstown' nan]

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

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

Valores únicos en sex: ['male', 'female']
Categories (2, object): ['female', 'male']
Valores únicos en embarked: ['S', 'C', 'Q', NaN]
Categories (3, object): ['C', 'Q', 'S']
Valores únicos en who: ['man', 'woman', 'child']
Categories (3, object): ['child', 'man', 'woman']
Valores únicos en embark_town: ['Southampton', 'Cherbourg', 'Queenstown', NaN]
Categories (3, object): ['Cherbourg', 'Queenstown', 'Southampton']

Casting variables Categoricas Ordinales

cols_categoricas_ord = ["pclass", "deck"]

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

Valores únicos en pclass: [3 1 2]
Valores únicos en deck: [NaN, 'C', 'E', 'G', 'D', 'A', 'B', 'F']
Categories (7, object): ['A', 'B', 'C', 'D', 'E', 'F', 'G']

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

Valores únicos en pclass: [3, 1, 2]
Categories (3, int64): [3 < 2 < 1]
Valores únicos en deck: [NaN, 'C', 'E', 'G', 'D', 'A', 'B', 'F']
Categories (7, object): ['A' < 'B' < 'C' < 'D' < 'E' < 'F' < 'G']

Casting variables booleanas

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

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

Resulado Casting

titanic.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 891 entries, 0 to 890
Data columns (total 15 columns):
 #   Column       Non-Null Count  Dtype
---  ------       --------------  -----
 0   survived     891 non-null    bool
 1   pclass       891 non-null    category
 2   sex          891 non-null    category
 3   age          714 non-null    float64
 4   sibsp        891 non-null    int64
 5   parch        891 non-null    int64
 6   fare         891 non-null    float64
 7   embarked     889 non-null    category
 8   class        891 non-null    category
 9   who          891 non-null    category
 10  adult_male   891 non-null    bool
 11  deck         203 non-null    category
 12  embark_town  889 non-null    category
 13  alive        891 non-null    bool
 14  alone        891 non-null    bool
dtypes: bool(4), category(7), float64(2), int64(2)
memory usage: 38.7 KB

Datos Faltantes (Missing data)

Métodos para Manejar datos faltantes en pandas:

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

A    1
B    2
C    0
dtype: int64

Eliminar datos Faltantes

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

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

Reemplazar los datos faltantes

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

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)

# crear un dataframe
df = pd.DataFrame(
    {
        "col1": [1, 2, 3, 4],
        "col2": [444, 555, 666, 444],
        "col3": ["abc", "def", "ghi", "xyz"],
    }
)
df

# valores únicos de la columna col2
df["col2"].unique()

array([444, 555, 666])

# Numero de valores únicos en el dataframe
df["col2"].nunique()

3

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

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

Datos Duplicados

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

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

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

Duplicados por Columna

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

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

el valor de jason esta duplicado en la columna name

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

Outliers

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

edad = titanic["age"]
edad

0      22.0
1      38.0
2      26.0
3      35.0
4      35.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 método .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
data = pd.DataFrame(
    {
        "gender": [
            "male",
            "male",
            "female",
            "female",
            "male",
            "female",
            "male",
            "female",
        ],
        "education_level": [
            "high school",
            "college",
            "college",
            "graduate",
            "high school",
            "graduate",
            "college",
            "graduate",
        ],
        "city": [
            "Boston",
            "Boston",
            "Miami",
            "Boston",
            "Miami",
            "Boston",
            "Miami",
            "Miami",
        ],
        "score": [75, 82, 88, 95, 69, 92, 78, 85],
    }
)
data

# Tabla de contingencia por Genero y nivel de educación
pd.crosstab(data["gender"], data["education_level"], margins=True)

# Tabla de contingencia de Genero, nivel de educación y ciudad
pd.crosstab([data["gender"], data["education_level"]], data["city"], margins=True)

pd.crosstab(
    data["gender"], data["education_level"], values=data["score"], aggfunc="mean"
)

# con los valores normalizados
pd.crosstab(data["gender"], data["education_level"], normalize=True, margins=True)

métodos y funciones en Pandas

Todos los métodos de los dataframe de pandas se pueden encontrar en:

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

Duplicados por Columna

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

# 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

métodos Basicos Pandas

Ejemplos simples de los métodos de los dataframe de pandas

Para información completa de los métodos 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 categórico no lo suma
df.sum()

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

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

10

# método en varias columnas
df[["col1", "col2"]].sum()

col1      10
col2    2109
dtype: int64

# Valor Mínimo cada Columna
df.min()

col1            1
col2          444
col3       HIJO
dtype: object

# Valor Máximo cada Columna
df.max()

col1          4
col2        666
col3    mama
dtype: object

métodos de información General

# Cargar la base de datos 'mpg' de la librería 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):
 #   Column        Non-Null Count  Dtype
---  ------        --------------  -----
 0   mpg           398 non-null    float64
 1   cylinders     398 non-null    int64
 2   displacement  398 non-null    float64
 3   horsepower    392 non-null    float64
 4   weight        398 non-null    int64
 5   acceleration  398 non-null    float64
 6   model_year    398 non-null    int64
 7   origin        398 non-null    object
 8   name          398 non-null    object
dtypes: float64(4), int64(3), object(2)
memory usage: 28.1+ KB

data.head()

data.describe()  # ver datos estadísticos de las columnas numéricas

data.describe(include="all")  # ver todos los datos incluidos los categóricos

# Descripción 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

métodos 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 métodos el parametro axis=1.

Ejemplo:

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

Esto funciona con los otros tipos de medidas estadisticas

# Se tomara la columna 'mpg' para realizar los cálculos
X = data["mpg"]
type(X)

pandas.core.series.Series

Medidas de centralizacion

estas funciones se aplican sobre un dataframe de pandas

Media

# Media Aritmética
X.mean()

23.514572864321607

# Media aritmética en un dataframe
data.mean(numeric_only=True)

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(numeric_only=True)

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

# Máximo
X.max()

46.6

# Máximo en un dataframe
data.max()

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

# Mínimo
X.min()

9.0

# Mínimo en un dataframe
data.min()

mpg                                 9.0
cylinders                             3
displacement                       68.0
horsepower                         46.0
weight                             1613
acceleration                        8.0
model_year                           70
origin                           europe
name            amc ambassador brougham
dtype: object

Moda

# Moda
X.mode()

0    13.0
Name: mpg, dtype: float64

# Moda en un dataframe
data.mode()