Summary
This chapter explains how to convert categorical variables into binary dummy features using pandas’ get_dummies function.

General domain of usage
Data preprocessing for machine learning

In this video, you will learn how to manage categorical variables in pandas using the Titanic dataset. Discover what categorical variables are and why they matter in data preprocessing. See how the pandas `.get_dummies()` function transforms columns like `'Sex'` and `'Embarked'` into dummy variables, making them suitable for analysis and machine learning. Follow along with practical examples as you convert these columns and interpret the resulting data, understanding how each category is represented by a new column with values of `1` or `0`. By the end, you will know how to efficiently handle categorical data using pandas and apply these techniques to your own datasets.

Ahora trabajarás con el conjunto de datos que no contiene valores faltantes. Los valores `NaN` de la columna `'Age'` fueron reemplazados por el **promedio** de la columna, y el valor `NaN` de la columna `'Fare'` fue eliminado.
Así que ahora es momento de aprender cómo gestionar variables categóricas. Categórico significa que tienen algunas categorías. Por ejemplo, en la columna `'Sex'`, están `'male'` y `'female'`; o en la columna `'Embarked'`, están `'Q'`, `'S'` y `'C'`.

**¿Qué debemos hacer para calcular la cantidad de valores en cada categoría o para obtener información sobre ellas?**

Ya conoces `.loc[]`, `.isin()`, `.between()` y muchas funciones, pero en pandas, existe una forma más elegante y conveniente de hacerlo. Utiliza la función `.get_dummies()`. Como ejemplo, la aplicaremos a la columna `'Embarked'`. Observa la implementación y el resultado (mostraremos los nombres de 5 pasajeros aleatorios y las nuevas columnas que creamos).

import pandas as pd
data = pd.read_csv('https://codefinity-content-media.s3.eu-west-1.amazonaws.com/4bf24830-59ba-4418-969b-aaf8117d522e/titanic3.csv', index_col = 0)
data = pd.get_dummies(data, columns = ['Embarked'])
print(data[['Name', 'Embarked_C', 'Embarked_Q', 'Embarked_S']].sample(5))

Analicemos una de las posibles salidas, específicamente una de las posibles combinaciones de **cinco filas seleccionadas aleatoriamente**. Puedes desplazarte horizontalmente por la tabla para ver todas las columnas:



**Explicación:**

Como resultado, nuestra función dividió la columna `'Embarked'` en tres columnas: `'Embarked_C'`, `'Embarked_Q'` y `'Embarked_S'`. En total, tenemos tres categorías. Cada pasajero tiene su categoría en la columna `'Embarked'`. Así, nuestra función crea tres columnas correspondientes a cada categoría y, en la fila de cada pasajero, coloca un `1` en la columna si la persona estaba relacionada inicialmente con esa geografía; de lo contrario, coloca un `0`. De este modo, obtenemos un `1` en solo una columna.

```python
pd.get_dummies(data, columns = ['Embarked'])
```
- `pd.get_dummies()` - esta función convierte variables **categóricas** en variables **dummy** (1 o 0);
- `data` - el data frame que se desea utilizar;
- `columns = ['Embarked']` - columnas que contienen variables categóricas que se desean transformar en variables dummy. Atención: es **obligatorio** colocar los nombres de las columnas en una lista.

import unittest
import pandas as pd
import io
import sys


def _dynamic_test(test_case, condition, success_msg, failure_msg):
    if condition:
        test_case._testMethodName = success_msg
        test_case.assertTrue(True, success_msg)
    else:
        test_case._testMethodName = failure_msg
        test_case.fail(failure_msg)


class TestDummyVariables(unittest.TestCase):
    def test_dummies_created_and_sums_correct(self):
        """
        1. Check that 'Sex' column was converted to dummy variables and sums are correct.
        """
        import user_code

        # reference dataset
        url = "https://codefinity-content-media.s3.eu-west-1.amazonaws.com/4bf24830-59ba-4418-969b-aaf8117d522e/titanic3.csv"
        df_ref = pd.read_csv(url, index_col=0)
        dummies_ref = pd.get_dummies(df_ref, columns=["Sex"])
        ref_sum_male = dummies_ref["Sex_male"].sum()
        ref_sum_female = dummies_ref["Sex_female"].sum()

        # user result
        assert hasattr(user_code, "data"), "Variable 'data' not found."
        df_user = user_code.data

        # check dummy columns exist and sums match
        condition = (
            "Sex_male" in df_user.columns
            and "Sex_female" in df_user.columns
            and abs(df_user["Sex_male"].sum() - ref_sum_male) < 1e-9
            and abs(df_user["Sex_female"].sum() - ref_sum_female) < 1e-9
        )

        _dynamic_test(
            self,
            condition,
            "The dummy variables 'Sex_male' and 'Sex_female' were created correctly and their sums are accurate.",
            "The dummy variable transformation or the calculated sums are incorrect."
        )


class TestOutput(unittest.TestCase):
    def test_output_print(self):
        """
        2. Check that both sums are printed in the output.
        """
        import user_code

        captured_output = io.StringIO()
        sys.stdout = captured_output
        print(user_code.sex_male, user_code.sex_female)
        sys.stdout = sys.__stdout__

        output_text = captured_output.getvalue().strip()
        # make sure both values appear in output
        parts = output_text.split()
        condition = len(parts) >= 2
        _dynamic_test(
            self,
            condition,
            "The sums of dummy variables are printed correctly.",
            "The output is missing or incorrect. Ensure you print both values: sex_male and sex_female."
        )


if __name__ == "__main__":
    unittest.main()

test_code.py

Este curso contiene muchas funciones útiles para un futuro analista de datos. Aprenderás diferentes formas de extraer datos e incluso establecer condiciones sobre ellos. Después de esto, estarás familiarizado con los métodos de agrupación de datos. Además, aprenderás cómo preprocesar datos. Cada sección tiene su propio conjunto de datos, lo que hace que el curso sea atractivo.

Esta sección te enseñará cómo mostrar columnas específicas por sus títulos o índices. Además, te familiarizarás con las formas en que puedes seleccionar filas por índices.

Aquí aprenderás cómo extraer datos que cumplen condiciones específicas. Además, aprenderás cómo combinarlas e incluso crear tus propias condiciones.

En esta sección, ampliarás tus conocimientos sobre cómo establecer diferentes condiciones de datos. Aprenderás a verificar si tus datos se encuentran en una lista definida de valores o entre dos valores. También aprenderás a encontrar los valores más grandes y más pequeños.

Esta sección es una de las más fascinantes del curso. Aquí aprenderás cómo agrupar datos de diferentes maneras. Te ayudará a trabajar como analista de datos para descubrir información sobre grupos de datos específicos.

Esta sección es una de las más significativas para un analista de datos porque si los datos contienen valores faltantes o en un formato incorrecto, será imposible trabajar con ellos. Por lo tanto, aquí aprenderás cómo tratar con dichos valores inapropiados.

Gestión de Variables Categóricas

Solución