Hoppa till huvudinnehållet

Great Expectations-handledning: Validera data med Python

Lär dig att validera dina data med Great Expectations i Python med denna end-to-end-handledning!
Uppdaterad 22 juli 2026  · 8 min läsa

Utforska med AI

Öppna i ChatGPTÖppna i ClaudeÖppna i Perplexity

Datakvalitet och konsistens är som grunden i ett hus—utan en stabil bas riskerar allt ovanpå att rasa. Här spelar datavalidering en viktig roll. Datavalidering hjälper dig säkerställa att dina data är korrekta, konsekventa och tillförlitliga.

Great Expectations är ett öppet verktyg för datavalidering som låter dig identifiera dataproblem tidigt och säkerställer att dina data uppfyller nödvändiga kvalitetskrav.

I den här guiden går vi igenom hur du använder Great Expectations för datavalidering, med ett praktiskt end-to-end-exempel som hjälper dig komma igång!

Vad är Great Expectations?

Great Expectations (GX) är ett open source-ramverk som har blivit populärt för att hantera och automatisera datavalidering i moderna datapipelines.

Dess Python-baserade ramverk är utformat för att hjälpa datateam att garantera kvaliteten och konsistensen i sina data. Användare kan definiera ”förväntningar”—regler eller tester som beskriver hur giltiga data ska se ut—som automatiskt validerar om data uppfyller dessa standarder.

Några fördelar med Great Expectations är:

  • Automatiserad datavalidering – Great Expectations automatiserar processen att validera data, minskar manuellt arbete och minimerar risken för fel. Det säkerställer att data konsekvent uppfyller fördefinierade standarder.
  • Integration med datapipelines – Det integreras enkelt med olika datakällor och plattformar, inklusive SQL-databasers, molnlagring och ETL-verktyg, vilket möjliggör datavalidering i olika steg av din pipeline.
  • Tydliga, åtgärdsbara valideringsresultat – Verktyget ger transparenta valideringsresultat, vilket gör det enkelt att upptäcka och snabbt åtgärda datakvalitetsproblem.
  • Datadokumentation – Great Expectations kan generera detaljerad, lättillgänglig dokumentation av dina datavalideringsprocesser, vilket hjälper team att enas om kvalitetsstandarder och ger en referens för framtiden.
  • Skalbarhet och flexibilitet – Som ett open source-verktyg är Great Expectations mycket anpassningsbart och kan skalas efter dina valideringsbehov, med flexibilitet att anpassa sig till olika användningsfall utan höga kostnader.

Nu tittar vi på ett end-to-end-exempel!

Konfigurera Great Expectations

I den här handledningen lär du dig hur du använder GX Core, open source-versionen av Great Expectations, för att validera en Pandas DataFrame. Vi går igenom hur du sätter upp en kontext, registrerar en Pandas-datakälla, definierar förväntningar och validerar databatcher.

Obs! Vi rekommenderar att du följer med i DataLab-notebooken, men du kan också skapa ditt eget Python-skript.

Förutsättningar

  • Python 3.9 till 3.12 installerat.
  • För att undvika konflikter rekommenderas starkt att du installerar Great Expectations i en virtuell miljö (friskrivning: inställning av virtuella miljöer ligger utanför den här artikelns omfång).
  • Ett exempeldata-set.

Obs! Om du använder den medföljande DataLab-notebooken är dessa förutsättningar redan uppfyllda. Du kan hoppa över dem.

Använd följande kommando för att installera GX via pip:

pip install great_expectations

Detta kommando installerar kärnpaketet och alla nödvändiga beroenden.

Great Expectations kräver en datakontext för att hantera konfigurationer. Vi använder en efemär datakontext för att undvika att spara konfigurationer.

import great_expectations as gx

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

Skapa din första datavalideringssvit

Nu när GX är konfigurerat skapar vi en datavalideringssvit.

En datakälla ansluter Great Expectations till dina data, medan en dataresurs representerar en specifik delmängd av data (t.ex. en tabell, DataFrame eller fil).

I det här fallet förbereder vi allt för att ansluta till en DataFrame som heter inventory_parts_df. Exempeldata-setet finns i den tillhandahållna DataLab, och det skapas när vi kör SQL-blocket:

Om du inte använder DataLab, skapa din egen DataFrame med exempeldata.

Skapa nu din datakälla och resurs:

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

En batchdefinition identifierar och organiserar dina data för validering. Här lägger vi till en batchdefinition som omfattar hela DataFrame:en:

# 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

En batch är en samling data kopplad till en batchdefinition. För att validera data behöver du hämta batchen och länka den till din DataFrame, i det här fallet 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)

Förväntningar är regler för att validera data. I det här exemplet definierar vi följande enkla förväntningar:

  1. Säkerställ att inventory_id-värden inte är null.
  2. Säkerställ att part_num-värden är unika.
# 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)

Du kan utforska alla tillgängliga förväntningar i Expectation Gallery. Lägg gärna till några fler!

Efter att ha definierat förväntningarna skriver GX ut konfigurationen för valideringssviten:

{
  "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
}

Sviten innehåller följande detaljer:

  1. Svitnamn och ID: Ett unikt namn (inventory_parts_suite) och en identifierare för att spåra och hantera sviten.
  2. Förväntningar: Varje regel specificerar:
    • Typ av kontroll (t.ex. att en kolumn saknar null-värden eller har unika poster).
    • Parametrar, såsom vilken kolumn som valideras.
    • Metadata och ett unikt ID för varje förväntning, vilket underlättar spårning och anpassning.
  3. Metadata: Versionsinformation för Great Expectations, som säkerställer kompatibilitet med verktyget.
  4. Anteckningar: En plats för att lägga till beskrivande kommentarer om sviten (valfritt).

Detta strukturerade utdata fungerar både som dokumentation och en återanvändbar konfiguration för att validera ditt dataset, så att dina förväntningar är tydligt definierade, spårbara och redo för framtida användning.

5. Validera data

Validera slutligen batchen mot de definierade förväntningarna och utvärdera resultaten.

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

Efter att ha kört valideringen ger Great Expectations en detaljerad rapport om huruvida datasetet uppfyller de definierade förväntningarna:

{
  "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
}

Den här rapporten beskriver kvaliteten på dina data och lyfter fram vad som lyckades och misslyckades. Här är en förenklad förklaring av resultaten:

Övergripande validering: Valideringen var delvis lyckad: 50 % av förväntningarna godkändes och 50 % underkändes. En underkänd förväntning indikerar ett datakvalitetsproblem som behöver åtgärdas. I det här fallet uppfyllde en kolumn inte den definierade regeln.

Förväntning 1: inventory_id ska sakna tomma värden

  • Resultat: Godkänt
  • Förklaring: Varje värde i kolumnen inventory_id finns, utan null eller saknade poster. Detta tyder på god datakompletthet för denna kolumn.

Förväntning 2: part_num ska ha unika värden

  • Resultat: Underkänt
  • Förklaring: Kolumnen part_num innehåller 97,98 % dubbletter, vilket innebär att bara några få värden är unika.
  • Höjdpunkter:
    • Exempel på dubblettvärden är ”3069b” och ”33291”.
    • Verktyget visar även hur ofta dessa dubbletter förekommer och deras radpositioner, vilket gör det enklare att lokalisera och rätta till problemen.

Detta är förstås bara ett exempeldata-set, och vi inkluderade medvetet en godkänd och en underkänd förväntning så att du kan se båda typerna av valideringsresultat.

Det var allt! Du har nu kört end-to-end-datavalideringar.

Integrera Great Expectations i datapipelines

I en produktionsmiljö måste valideringar bäddas in direkt i arbetsflödet för att kontinuerligt övervaka datakvalitet i varje steg. 

I det här avsnittet diskuterar vi hur du kan integrera Great Expectations i dina datapipelines.

Detta är exempel för att ge dig en uppfattning, och extra konfigurationer som inte ingår här kan krävas. Kolla respektive verktygs dokumentation för uppdaterad syntax!

Integration med ETL-verktyg

Att integrera Great Expectations med populära ETL-verktyg som Apache Airflow eller Prefect är relativt enkelt. Genom att bädda in valideringssteg direkt i ETL-processerna kan du fånga och åtgärda dataproblem i realtid innan de påverkar analyser längre nedströms.

Låt oss gå igenom ett enkelt exempel på hur man integrerar Great Expectations med Prefect för att köra datavalidering som en del av ett automatiserat ETL-arbetsflöde:

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

I det här exemplet definierar vi ett Prefect-flöde med en uppgift för att köra validering med Great Expectations.

Uppgiften validate_data() laddar Great Expectations-kontexten, hämtar databatchen och tillämpar valideringssviten. 

Om data inte uppfyller valideringskriterierna utlöser uppgiften en varning, stoppar arbetsflödet och förhindrar fel nedströms.

Kontinuerlig datavalidering

Du kan schemalägga valideringsjobb med olika verktyg, som cron-jobb på Unix-baserade system eller hanterade tjänster som Apache Airflow. I det här exemplet visar vi hur du schemalägger valideringskörningar med Airflow, som passar bra för att orkestrera datapipelines.

Så här kan du sätta upp en Airflow-DAG (Directed Acyclic Graph) för att köra Great Expectations-valideringar dagligen:

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

I det här exemplet definierar vi en DAG som schemalägger en valideringskörning en gång per dag (@daily). 

Funktionen run_validation() kör valideringen genom att ladda Great Expectations-kontexten och köra den definierade valideringssviten mot datan.

Best practices för datavalidering med Great Expectations

Att följa best practices är alltid klokt för skalbarhet och effektivitet, och det gäller även datavalidering med Great Expectations.

Börja smått och iterera

Börja med grundläggande datakvalitetskontroller och bygg successivt ut. Det är bättre att fokusera på basala förväntningar inledningsvis, eftersom det hjälper till att undvika onödig komplexitet—det ger en smidigare integration och enklare felsökning. När din förståelse för datasetet förbättras kan du lägga till mer avancerade valideringar.

Samarbeta över team

Datakvalitet är inte bara en teknisk fråga. Samarbeta med verksamhetssidan för att definiera förväntningar och säkerställa att den implementerade valideringen stämmer överens med den underliggande affärslogiken och målen. Detta tvärfunktionella arbetssätt garanterar att data tjänar sitt avsedda syfte och uppfyller alla intressenters krav.

Automatisera där det är möjligt

Automatisera processen där det är möjligt för att integrera datavalidering i datapipelines. Genom att integrera automatiserade valideringskontroller möjliggörs kontinuerlig övervakning av datakvalitet utan manuell handpåläggning, vilket avsevärt förbättrar effektiviteten.

Slutsats

Bra jobbat! Du har lärt dig hur man konfigurerar och validerar data i Great Expectations. Dessa tekniker hjälper dig att upprätthålla hög datakvalitet och transparens i dina arbetsflöden.

Fortsätt bygga dina färdigheter med dessa resurser:

FAQs

Hur står sig Great Expectations jämfört med andra datavalideringsverktyg?

Great Expectations är open source, flexibelt och integreras väl med moderna datapipelines. Det utmärker sig genom sitt omfattande bibliotek av förväntningar och sin starka dokumentation.

Måste jag kunna Python för att använda Great Expectations?

Även om grundläggande Python-kunskaper är hjälpsamma, erbjuder Great Expectations ett användarvänligt CLI och omfattande dokumentation, vilket gör det tillgängligt även för icke-programmerare.

Vilka typer av datakällor stöder Great Expectations?

Great Expectations stöder ett brett utbud av datakällor, inklusive:

  • Relationsdatabaser som PostgreSQL, MySQL och SQL Server.
  • Molnlagringstjänster som AWS S3, Google Cloud Storage och Azure Blob Storage.
  • Filformat som CSV, Parquet och Excel.
  • Stordataramverk som Apache Spark och Databricks. Du kan enkelt ansluta Great Expectations till dessa källor med rätt konfiguration för din datakälla.

Kan jag använda Great Expectations med strömmande data?

Great Expectations är främst utformat för batchdatavalidering. Även om det inte har inbyggt stöd för strömmande datapipelines kan du integrera det i ramverk som Apache Kafka eller Spark Structured Streaming genom att validera ögonblicksbilder eller mikrobatcher av data periodiskt.

Är det möjligt att versionshantera förväntningar och valideringsresultat?

Ja, du kan versionshantera förväntningar och konfigurationer genom att lagra dem som YAML- eller JSON-filer i ett Git-repo. För valideringsresultat kan du sätta upp en databas- eller filbaserad lagring för att följa resultaten över tid och integrera dem i dina CI/CD-pipelines för kontinuerlig övervakning.

Hur hanterar Great Expectations schemaevolution i dataset?

Great Expectations hanterar schemaevolution genom sitt flexibla förväntningsramverk. Om ditt schema ändras kan du:

  • Använda expect_table_columns_to_match_set eller liknande förväntningar för att validera kolumnnamn dynamiskt.
  • Ändra eller skapa nya valideringssviter för att anpassa dig till det nya schemat.
  • Utnyttja verktyg för schemainferens för att automatiskt uppdatera förväntningar för nyligen tillagda kolumner.
Ämnen
Python
Data engineering

Lär dig mer om data engineering med dessa kurser!

track

Dataingenjör i Python

40 timmar
Få efterfrågade färdigheter för att effektivt ta in, rensa och hantera data samt schemalägga och övervaka pipelines, så att du sticker ut inom data engineering.
Se detaljerRight Arrow
Starta Kursen
Se merRight Arrow