Saltar al contenido principal

Tutorial de Grandes esperanzas: Validar datos con Python

¡Aprende a validar tus datos con Grandes Expectativas en Python con este tutorial de principio a fin!
Actualizado 29 nov 2024  · 20 min de lectura

La calidad y la coherencia de los datos son como los cimientos de una casa: sin una base sólida, todo lo que se construya encima corre el riesgo de derrumbarse. Aquí es donde la validación de datos desempeña un papel importante. La validación de datos te ayuda a asegurarte de que tus datos son precisos, coherentes y fiables.

Great Expectations es una herramienta de validación de datos de código abierto que te permite identificar los problemas de los datos en una fase temprana y garantiza que tus datos cumplen las normas de calidad requeridas.

En esta guía, te guiaremos a través del proceso de utilización de Grandes Expectativas para la validación de datos, con un ejemplo práctico de principio a fin que te ayudará a empezar.

¿Qué es Grandes esperanzas?

Great Expectations (GX) es un marco de trabajo de código abierto que se ha hecho popular para gestionar y automatizar la validación de datos en los conductos de datos modernos.

Su marco basado en Python está diseñado para ayudar a los equipos de datos a garantizar la calidad y coherencia de sus datos. Los usuarios pueden definir "expectativas" -reglas o pruebas que describen cómo deben ser los datos válidos- que validan automáticamente si los datos cumplen estas normas.

Algunas de las ventajas de Grandes esperanzas son

  • Validación automatizada de datos - Great Expectations automatiza el proceso de validación de datos, reduciendo el esfuerzo manual y minimizando el riesgo de errores. Garantiza que los datos cumplan sistemáticamente las normas predefinidas.
  • Integración con canalizaciones de datos - Se integra fácilmente con varias fuentes y plataformas de datos, incluidas bases de datos SQL, almacenamiento en la nube y herramientas ETL, lo quepermite la validación de datos en las distintas fases de tu canalización.
  • Resultados de validación claros y procesables - La herramienta proporciona resultados de validación transparentes, lo que facilita la detección de problemas de calidad de los datos y su rápida resolución.
  • Documentación de datos - Great Expectations puede generar documentación detallada y accesible de tus procesos de validación de datos, ayudando a los equipos a alinearse con las normas de calidad y proporcionando una referencia para uso futuro.
  • Escalabilidad y flexibilidad - Como herramienta de código abierto, Great Expectations es altamente personalizable y puede escalar con tus necesidades de validación de datos, ofreciendo flexibilidad para ajustarse a diversos casos de uso sin costes elevados.

Veamos ahora un ejemplo de extremo a extremo.

Conviértete en Ingeniero de Datos

Desarrolla tus habilidades en Python para convertirte en un ingeniero de datos profesional.
Empieza gratis

Crear grandes expectativas

En este tutorial, aprenderás a utilizar GX Core, la versión de código abierto de Grandes Expectativas, para validar un DataFrame de Pandas. Pasaremos por la configuración de un contexto, el registro de una fuente de datos Pandas, la definición de expectativas y la validación de lotes de datos.

Nota: Te recomendamos que sigas el cuaderno DataLab, pero también puedes crear tu propio script en Python.

Requisitos previos

  • Python 3.9 a 3.12 instalado.
  • Para evitar conflictos, se recomienda encarecidamente que instales Grandes esperanzas en un entorno virtual (descargo de responsabilidad: la instalación de entornos virtuales está fuera del alcance de este artículo).
  • Un conjunto de datos de muestra.

Nota: Si utilizas el cuaderno DataLab proporcionado, estos requisitos previos ya se habrán cumplido. Siéntete libre de saltártelos.

Utiliza el siguiente comando para instalar GX mediante pip:

pip install great_expectations

Este comando instala el paquete principal y todas las dependencias necesarias.

Grandes Expectativas requiere un contexto de datos para gestionar las configuraciones. Utilizamos un contexto de datos efímero para evitar la persistencia de las configuraciones.

import great_expectations as gx

# Get the Ephemeral Data Context
context = gx.get_context()
assert type(context).__name__ == "EphemeralDataContext"

Crear tu primer paquete de validación de datos

Ahora que GX está configurado, vamos a crear un conjunto de validación de datos.

Una fuente de datos conecta Great Expectations a tus datos, mientras que un activo de datos representa un subconjunto específico de datos (por ejemplo, una tabla, un DataFrame o un archivo).

En este caso, prepararemos todo para conectarnos a un DataFrame llamado inventory_parts_df. El conjunto de datos de muestra está disponible en el DataLab proporcionado, y se crea una vez que ejecutamos el bloque SQL:

Si no utilizas DataLab, crea tu propio DataFrame con datos de ejemplo.

Ahora, crea tu fuente de datos y tu activo:

# Add a Pandas Data Source
data_source = context.data_sources.add_pandas(name="inventory_parts")
# Add a Data Asset to the Data Source
data_asset = data_source.add_dataframe_asset(name="inventory_parts_asset")

Una definición de lote identifica y organiza tus datos para la validación. Aquí, añadimos una definición de lote que abarca todo el DataFrame:

# Define the Batch Definition name
batch_definition_name = "inventory_parts_batch"
# Add the Batch Definition
batch_definition = data_asset.add_batch_definition_whole_dataframe(batch_definition_name)
assert batch_definition.name == batch_definition_name

Un lote es una colección de datos vinculada a una definición de lote. Para validar los datos, tendrás que recuperar y vincular el lote a tu DataFrame, en este caso inventory_parts_df:

# Define the Batch Parameters
batch_parameters = {"dataframe": inventory_parts_df}
# Retrieve the Batch
batch = batch_definition.get_batch(batch_parameters=batch_parameters)

Las expectativas son normas para validar los datos. En este ejemplo, definiremos las siguientes expectativas sencillas:

  1. Asegúrate de que los valores de inventory_id no sean nulos.
  2. Asegúrate de que los valores de part_num son únicos.
# Create an Expectation Suite
expectation_suite_name = "inventory_parts_suite"
suite = gx.ExpectationSuite(name=expectation_suite_name)
# Add Expectations
suite.add_expectation(
    gx.expectations.ExpectColumnValuesToNotBeNull(column="inventory_id")
)
suite.add_expectation(
    gx.expectations.ExpectColumnValuesToBeUnique(column="part_num")
)
# Add the Expectation Suite to the Context
context.suites.add(suite)

Puedes explorar todas las expectativas disponibles en la Galería de Expectativas. ¡Te animamos a que añadas algunas más!

Tras definir las expectativas, GX da salida a la configuración del conjunto de expectativas:

{
  "name": "inventory_parts_suite",
  "id": "b2de0b69-0869-4163-8dde-6c09884483f7",
  "expectations": [
    {
      "type": "expect_column_values_to_not_be_null",
      "kwargs": {
        "column": "inventory_id"
      },
      "meta": {},
      "id": "53d6c42a-d190-412f-a113-783b706531f4"
    },
    {
      "type": "expect_column_values_to_be_unique",
      "kwargs": {
        "column": "part_num"
      },
      "meta": {},
      "id": "362a2bdc-616d-4b3a-b7f0-c73808caee78"
    }
  ],
  "meta": {
    "great_expectations_version": "1.2.4"
  },
  "notes": null
}

La suite incluye los siguientes detalles:

  1. Nombre e ID de la suite: Un nombre único (inventory_parts_suite) y un identificador para rastrear y gestionar la suite.
  2. Expectativas: Cada regla especifica:
    • El tipo de comprobación (por ejemplo, asegurarse de que una columna no tiene valores nulos o entradas únicas).
    • Parámetros, como la columna que se está validando.
    • Metadatos y un ID único para cada expectativa, lo que permite un seguimiento y una personalización más sencillos.
  3. Metadata: Información sobre la versión de Grandes esperanzas, que garantiza la compatibilidad con la herramienta.
  4. Notas: Un marcador de posición para añadir comentarios descriptivos sobre el conjunto (opcional).

Este resultado estructurado actúa como documentación y como configuración reutilizable para validar tu conjunto de datos, de modo que tus expectativas estén claramente definidas, sean trazables y estén listas para su uso futuro.

5. Validar los datos

Por último, valida el lote frente a las expectativas definidas y evalúa los resultados.

# Validate the Data Against the Suite
validation_results = batch.validate(suite)
# Evaluate the Results
print(validation_results)

Tras ejecutar la validación, Grandes Expectativas proporciona un informe detallado sobre si el conjunto de datos cumple las expectativas definidas:

{
  "success": false,
  "results": [
    {
      "success": true,
      "expectation_config": {
        "type": "expect_column_values_to_not_be_null",
        "kwargs": {
          "batch_id": "inventory_parts-inventory_parts_asset",
          "column": "inventory_id"
        },
        "meta": {},
        "id": "53d6c42a-d190-412f-a113-783b706531f4"
      },
      "result": {
        "element_count": 580069,
        "unexpected_count": 0,
        "unexpected_percent": 0.0,
        "partial_unexpected_list": [],
        "partial_unexpected_counts": [],
        "partial_unexpected_index_list": []
      },
      "meta": {},
      "exception_info": {
        "raised_exception": false,
        "exception_traceback": null,
        "exception_message": null
      }
    },
    {
      "success": false,
      "expectation_config": {
        "type": "expect_column_values_to_be_unique",
        "kwargs": {
          "batch_id": "inventory_parts-inventory_parts_asset",
          "column": "part_num"
        },
        "meta": {},
        "id": "362a2bdc-616d-4b3a-b7f0-c73808caee78"
      },
      "result": {
        "element_count": 580069,
        "unexpected_count": 568352,
        "unexpected_percent": 97.98006788847535,
        "partial_unexpected_list": [
          "48379c01",
          "paddle",
          "11816pr0005",
          "2343",
          "3003",
          "30176",
          "3020",
          "3022",
          "3023",
          "30357",
          "3039",
          "3062b",
          "3068b",
          "3069b",
          "3069b",
          "33291",
          "33291",
          "3795",
          "3941",
          "3960"
        ],
        "missing_count": 0,
        "missing_percent": 0.0,
        "unexpected_percent_total": 97.98006788847535,
        "unexpected_percent_nonmissing": 97.98006788847535,
        "partial_unexpected_counts": [
          {
            "value": "3069b",
            "count": 2
          },
          {
            "value": "33291",
            "count": 2
          },
          {
            "value": "11816pr0005",
            "count": 1
          },
          {
            "value": "2343",
            "count": 1
          },
          {
            "value": "3003",
            "count": 1
          },
          {
            "value": "30176",
            "count": 1
          },
          {
            "value": "3020",
            "count": 1
          },
          {
            "value": "3022",
            "count": 1
          },
          {
            "value": "3023",
            "count": 1
          },
          {
            "value": "30357",
            "count": 1
          },
          {
            "value": "3039",
            "count": 1
          },
          {
            "value": "3062b",
            "count": 1
          },
          {
            "value": "3068b",
            "count": 1
          },
          {
            "value": "3795",
            "count": 1
          },
          {
            "value": "3941",
            "count": 1
          },
          {
            "value": "3960",
            "count": 1
          },
          {
            "value": "48379c01",
            "count": 1
          },
          {
            "value": "paddle",
            "count": 1
          }
        ],
        "partial_unexpected_index_list": [
          0,
          3,
          4,
          5,
          6,
          7,
          8,
          9,
          10,
          11,
          12,
          13,
          14,
          15,
          16,
          17,
          18,
          19,
          20,
          21
        ]
      },
      "meta": {},
      "exception_info": {
        "raised_exception": false,
        "exception_traceback": null,
        "exception_message": null
      }
    }
  ],
  "suite_name": "inventory_parts_suite",
  "suite_parameters": {},
  "statistics": {
    "evaluated_expectations": 2,
    "successful_expectations": 1,
    "unsuccessful_expectations": 1,
    "success_percent": 50.0
  },
  "meta": {
    "great_expectations_version": "1.2.4",
    "batch_spec": {
      "batch_data": "PandasDataFrame"
    },
    "batch_markers": {
      "ge_load_time": "20241129T122532.416424Z",
      "pandas_data_fingerprint": "84a1e1939091fcf54324910def3b89cd"
    },
    "active_batch_definition": {
      "datasource_name": "inventory_parts",
      "data_connector_name": "fluent",
      "data_asset_name": "inventory_parts_asset",
      "batch_identifiers": {
        "dataframe": "<DATAFRAME>"
      }
    }
  },
  "id": null
}

Este informe detalla la calidad de tus datos, destacando los éxitos y los fracasos. He aquí una explicación simplificada de los resultados:

Validación global: El resultado de la validación fue parcialmente satisfactorio: El 50% de las expectativas se superaron y el otro 50% fracasaron. Una expectativa fallida indica un problema de calidad de los datos que requiere atención. En este caso, una columna no cumplía la regla definida.

Expectativa 1: inventory_id no deben faltar valores

  • Resultado: Aprobado
  • Explicación: Todos los valores de la columna inventory_id están presentes, sin entradas nulas o ausentes. Esto indica una buena integridad de los datos de esta columna.

Expectativa 2: part_num deben tener valores únicos

  • Resultado: Fallido
  • Explicación: La columna part_num contiene un 97,98% de valores duplicados, lo que significa que sólo unos pocos valores son únicos.
  • Lo más destacado:
    • Algunos ejemplos de valores duplicados son "3069b" y "33291".
    • La herramienta también muestra la frecuencia con que aparecen estos duplicados y sus posiciones en las filas, lo que facilita la localización y solución de los problemas.

Por supuesto, se trata sólo de un conjunto de datos de muestra, y hemos incluido a propósito una expectativa de aprobado y otra de suspenso para que puedas ver los resultados de ambas validaciones.

Eso es. Has realizado con éxito validaciones de datos de extremo a extremo.

Integrar las Grandes Expectativas en las Cadenas de Datos

En un entorno de producción, las validaciones deben integrarse directamente en el flujo de trabajo para controlar continuamente la calidad de los datos en cada etapa. 

En esta sección, hablaremos de cómo puedes integrar Grandes Expectativas en tus canalizaciones de datos.

Estos son ejemplos para que te hagas una idea, y pueden ser necesarias configuraciones adicionales no incluidas aquí. Consulta la documentación de cada herramienta para conocer la sintaxis actualizada.

Integración con herramientas ETL

Integrar Great Expectations con herramientas ETL populares como Apache Airflow o Prefect es relativamente sencillo. Integrar los pasos de validación directamente en los procesos ETL te permitirá detectar y resolver los problemas de los datos en tiempo real, antes de que afecten al análisis posterior.

Veamos un ejemplo sencillo de integración de Great Expectations con Prefect para ejecutar la validación de datos como parte de un flujo de trabajo ETL automatizado:

from prefect import task, Flow
import great_expectations as ge
# Define a task to run Great Expectations validation
@task
def validate_data():
    context = ge.data_context.DataContext()
    batch_kwargs = {"path": "path/to/your/datafile.csv", "datasource": "your_datasource"}
    batch = context.get_batch(batch_kwargs, suite_name="your_expectation_suite")
    results = context.run_validation_operator("action_list_operator", assets_to_validate=[batch])
	    
    # Check validation results and raise an alert if validation fails
    if not results["success"]:
        raise ValueError("Data validation failed!")
# Define your ETL flow
with Flow("ETL_with_GE_Validation") as flow:
    validation = validate_data()
# Execute the flow
flow.run()

En este ejemplo, definimos un flujo Prefecto con una tarea para ejecutar la validación de Grandes esperanzas.

La tarea validate_data() carga el contexto Grandes Expectativas, recupera el lote de datos y aplica el conjunto de expectativas. 

Si los datos no cumplen los criterios de validación, la tarea emite una alerta, deteniendo el flujo de trabajo y evitando errores posteriores.

Validación continua de datos

Puedes programar trabajos de validación utilizando varias herramientas, como trabajos cron en sistemas basados en Unix o servicios gestionados como Apache Airflow. En este ejemplo, mostraremos cómo programar ejecuciones de validación utilizando Airflow, que es muy adecuado para orquestar canalizaciones de datos.

A continuación te explicamos cómo puedes configurar un Airflow DAG(grafo acíclico dirigido) para ejecutar diariamente las validaciones de Grandes Expectativas:

from airflow import DAG
from airflow.operators.python_operator import PythonOperator
from datetime import datetime
import great_expectations as ge
# Define the DAG and set the schedule to run daily
default_args = {
	  'owner': 'airflow',
	  'start_date': datetime(2024, 1, 1),
	  'retries': 1,
}
dag = DAG(
      'great_expectations_validation',
	default_args=default_args,
	schedule_interval='@daily',  # Runs once a day
)
# Define the function to run the validation
def run_validation():
    context = ge.data_context.DataContext()
    batch = context.get_batch(batch_kwargs, suite_name="your_expectation_suite")
    results = context.run_validation_operator("action_list_operator", assets_to_validate=[batch])
    return results
# Set up the task in Airflow
validation_task = PythonOperator(
      task_id='run_great_expectations_validation',
      python_callable=run_validation,
      dag=dag,
)
# Set the task in the DAG
validation_task

En este ejemplo, definimos un DAG que programa una ejecución de validación una vez al día (@daily). 

La función run_validation() ejecuta la validación cargando el contexto Grandes Expectativas y ejecutando el conjunto de expectativas definido con los datos.

Buenas prácticas para la validación de datos con grandes expectativas

Seguir las mejores prácticas es siempre lo más aconsejable para la escalabilidad y la eficacia, y no es diferente para la validación de datos con Great Expectations.

Empieza poco a poco e itera

Empieza con comprobaciones básicas de la calidad de los datos y amplíalas gradualmente. Es mejor centrarse inicialmente en las expectativas básicas, ya que así se evita complicar demasiado el proceso, lo que facilita la integración y la resolución de problemas. A medida que mejore tu comprensión del conjunto de datos, podrás añadir validaciones más complejas.

Colaborar entre equipos

La calidad de los datos no es sólo una cuestión técnica. Colabora con todos los equipos empresariales para definir las expectativas y garantizar que la validación implementada se alinea con la lógica y los objetivos empresariales subyacentes. Este enfoque interfuncional garantiza que los datos sirvan para el fin previsto y satisfagan los requisitos de todas las partes interesadas.

Automatiza cuando sea posible

Automatiza el proceso siempre que sea factible para integrar la validación de datos en los pipelines de datos. La integración de comprobaciones de validación automatizadas permite una supervisión continua de la calidad de los datos sin intervención manual, lo que mejora notablemente la eficacia.

Conclusión

¡Gran trabajo! Has aprendido a configurar y validar datos en Grandes Expectativas. Estas técnicas te ayudarán a mantener una alta calidad de datos y transparencia en tus flujos de trabajo.

Para seguir desarrollando tus habilidades, consulta estos recursos:

Conviértete en Ingeniero de Datos

Demuestra tus habilidades como ingeniero de datos preparado para el trabajo.

Preguntas frecuentes

¿Cómo se compara Great Expectations con otras herramientas de validación de datos?

Great Expectations es de código abierto, flexible y se integra bien con los conductos de datos modernos. Destaca por su amplia biblioteca de expectativas y su sólida documentación.

¿Necesito saber Python para utilizar Grandes Esperanzas?

Aunque es útil tener conocimientos básicos de Python, Great Expectations proporciona una CLI fácil de usar y una amplia documentación, lo que lo hace accesible a los no programadores.

¿Qué tipos de fuentes de datos admite Great Expectations?

Great Expectations admite una amplia gama de fuentes de datos, entre las que se incluyen:

  • Bases de datos relacionales como PostgreSQL, MySQL y SQL Server.
  • Soluciones de almacenamiento en la nube como AWS S3, Google Cloud Storage y Azure Blob Storage.
  • Formatos de archivo como CSV, Parquet y Excel.
  • Marcos de Big Data como Apache Spark y Databricks. Puedes conectar fácilmente Great Expectations a estas fuentes utilizando la configuración adecuada para tu fuente de datos.

¿Puedo utilizar Grandes esperanzas con datos en streaming?

Great Expectations está diseñado principalmente para la validación de datos por lotes. Aunque no admite de forma nativa canalizaciones de datos en streaming, puedes integrarlo en marcos como Apache Kafka o Spark Structured Streaming validando instantáneas o microlotes de datos periódicamente.

¿Es posible controlar la versión de las expectativas y los resultados de la validación?

Sí, puedes controlar las versiones de las expectativas y configuraciones almacenándolas como archivos YAML o JSON en un repositorio Git. Para los resultados de validación, puedes crear una base de datos o un almacén basado en archivos para realizar un seguimiento de los resultados a lo largo del tiempo e integrarlos en tus canalizaciones CI/CD para una supervisión continua.

¿Cómo gestiona Great Expectations la evolución del esquema en los conjuntos de datos?

Great Expectations gestiona la evolución de los esquemas mediante su marco flexible de expectativas. Si tu esquema cambia, puedes

  • Utiliza expect_table_columns_to_match_set o expectativas similares para validar dinámicamente los nombres de las columnas.
  • Modifica o crea nuevas suites de expectativas para adaptarlas al nuevo esquema.
  • Aprovecha las herramientas de inferencia de esquemas para actualizar automáticamente las expectativas de las columnas recién añadidas.

Kurtis Pykes 's photo
Author
Kurtis Pykes
LinkedIn

Thalia Barrera's photo
Author
Thalia Barrera

Thalia Barrera es Editora Senior de Ciencia de Datos en DataCamp, con un máster en Informática y más de una década de experiencia en ingeniería de software y datos. Thalia disfruta simplificando conceptos tecnológicos para ingenieros y científicos de datos a través de publicaciones en blogs, tutoriales y cursos en vídeo.

Temas

¡Aprende más sobre ingeniería de datos con estos cursos!

programa

Data Engineer

40hrs hr
Gain in-demand skills to efficiently ingest, clean, manage data, and schedule and monitor pipelines, setting you apart in the data engineering field.
Ver detallesRight Arrow
Comienza el curso
Ver másRight Arrow
Relacionado

tutorial

Tutorial de funciones de Python

Un tutorial sobre funciones en Python que cubre cómo escribir funciones, cómo invocarlas y mucho más.
Karlijn Willems's photo

Karlijn Willems

14 min

tutorial

Tutorial de Excel en Python: La guía definitiva

Aprende a leer e importar archivos Excel en Python, a escribir datos en estas hojas de cálculo y a encontrar los mejores paquetes para hacerlo.
Natassha Selvaraj's photo

Natassha Selvaraj

30 min

tutorial

Tutorial de visualización de datos con Python y Tableau

Aprende a utilizar Python para ampliar las funciones de visualización de datos de Tableau.
Abid Ali Awan's photo

Abid Ali Awan

15 min

tutorial

Sentencias IF, ELIF y ELSE de Python

En este tutorial, aprenderás exclusivamente sobre las sentencias if else de Python.
Sejal Jaiswal's photo

Sejal Jaiswal

9 min

tutorial

Tutorial de pandas en Python: la guía definitiva para principiantes

¿Todo preparado para comenzar tu viaje de pandas? Aquí tienes una guía paso a paso sobre cómo empezar.
Vidhi Chugh's photo

Vidhi Chugh

15 min

tutorial

Tutorial de Python String format()

Aprende a formatear cadenas en Python.
DataCamp Team's photo

DataCamp Team

5 min

See MoreSee More