aiMOOC

Programmieren für technische Aufgaben – Dateien strukturiert einlesen und schreiben

QR-Code

Programmieren für technische Aufgaben – Dateien strukturiert einlesen und schreiben

Kurzbeschreibung: Lerne, wie Du mit Python technische Daten in CSV- und JSON-Dateien strukturiert einliest, prüfst, verarbeitest und speicherst.

Zielgruppe: Ausbildung in technischen und IT-Berufen

Niveau: Grundlagen bis Anwendung

Lernzeit: ca. 120–180 Minuten

Vorkenntnisse: Python-Grundlagen, Variablen, Listen, Schleifen und Bedingungen

Dein Lernziel: Du entwickelst eine kleine, nachvollziehbare Messdatenauswertung mit sicheren lokalen Tests.

Das lernst Du

CSV: Tabellarische Daten lesen und schreiben.
JSON: Strukturierte Ergebnisse speichern.
Datenvalidierung: Fehlerhafte Messwerte erkennen.
Datenverarbeitung: Prüfstatus und Mittelwerte berechnen.
Softwaretest: Programme mit fiktiven Testfällen überprüfen.
Dokumentation: Ergebnisse nachvollziehbar darstellen.

Deine sichere Lernumgebung

Alle Programmierbeispiele verwenden ausschließlich erfundene Daten. Du benötigst Python 3 mit den Standardbibliotheken `csv`, `json`, `io`, `math`, `pathlib` und `tempfile`.

Führe die Beispiele nur in einer lokalen, zum Lernen freigegebenen Umgebung aus. Verwende keine Kundendaten, Zugangsdaten, fremden Netzwerke oder Verbindungen zu realen Produktionsanlagen. Die Übungen benötigen keine Internetverbindung und versenden keine Daten.

Wichtig: Die Dateibeispiele nutzen automatisch angelegte temporäre Verzeichnisse. Nach Programmende werden diese wieder entfernt. Arbeite nicht in einem produktiven Projektverzeichnis.

Ausbildungsfall: Messdaten einer fiktiven Prüfstation

Du arbeitest als Auszubildende oder Auszubildender in einer erfundenen Elektronikwerkstatt. Vier Übungsbauteile werden hinsichtlich ihrer Spannung geprüft.

Die zulässige Spannung beträgt im fiktiven Lernfall 11,5 bis 12,5 Volt einschließlich der Grenzwerte. Diese Zahlen sind keine allgemein gültigen technischen Sicherheitsgrenzen.

Datei:Generic Folder.svg

Ausgangsdaten

Prüfling	Spannung	Bewertung
P-101	11,9 V	OK
P-102	12,3 V	OK
P-103	10,8 V	PRÜFEN
P-104	12,2 V	OK

Arbeitsauftrag: Entwickle ein Python-Programm, das aus diesen Messwerten eine CSV-Ergebnisdatei und einen JSON-Prüfbericht erstellt.

Der geplante Datenfluss

Datei:Extract, Transform, Load Data Flow Diagram.svg

Die Grafik illustriert das allgemeine Prinzip der Datenverarbeitung. Unser konkreter Ablauf lautet:

Fiktive Messwerte
       |
       v
CSV-Datei erzeugen
       |
       v
CSV-Datei einlesen
       |
       v
Spalten und Werte prüfen
       |
       v
Prüfstatus berechnen
       |
       +------> Ergebnis-CSV
       |
       +------> JSON-Prüfbericht
       |
       v
Ergebnis erneut prüfen

Dieses Verfahren verbindet Eingabe – Verarbeitung – Ausgabe mit Datenvalidierung und Qualitätssicherung.

Lerneinheit 1: CSV verstehen

Dauer: ca. 15 Minuten

Fehler beim Erstellen des Vorschaubildes:

CSV bedeutet Comma-Separated Values. Die Daten sind zeilen- und spaltenförmig organisiert. Als Feldtrennzeichen können beispielsweise Komma oder Semikolon verwendet werden.

Beispiel einer CSV-Datei

id;spannung_v
P-101;11.9
P-102;12.3
P-103;10.8
P-104;12.2

Die erste Zeile enthält die Feldnamen. In dieser Übung ist das Semikolon das Trennzeichen. Dezimalzahlen verwenden im Dateiformat ausdrücklich den Punkt.

Merke: CSV speichert zunächst Text. Zahlen musst Du für Berechnungen bewusst in einen numerischen Datentyp umwandeln.

Lokales Miniprogramm: CSV lesen

Dieses Beispiel verarbeitet nur einen Text im Arbeitsspeicher. Es legt keine Dateien an.

import csv
from io import StringIO

text = """id;spannung_v
P-101;11.9
P-102;12.3
"""

datei = StringIO(text)
daten = csv.DictReader(datei, delimiter=";")

for zeile in daten:
    wert = float(zeile["spannung_v"])
    print(zeile["id"], wert)

Erwartete Ausgabe:

P-101 11.9
P-102 12.3

Basisaufgabe: Ergänze einen dritten fiktiven Prüfling.

Feedback: Wenn drei unterschiedliche Datensätze erscheinen, ist die neue Zeile korrekt eingelesen. Eine fehlerhafte Feldtrennung verhindert dagegen die richtige Zuordnung.

Lernvideo: CSV in Python

Corey Schafer: Python Tutorial – CSV Module (englisch). Das Video erläutert Einlesen und Schreiben mit der Python-Standardbibliothek.

Beobachtungsauftrag: Achte auf den Unterschied zwischen `csv.reader`, `csv.DictReader` und `csv.writer`.

Lerneinheit 2: JSON verstehen

Dauer: ca. 15 Minuten

Datei:JSON vector logo.svg

JSON bedeutet JavaScript Object Notation. Es eignet sich besonders für strukturierte Daten mit benannten Eigenschaften, Listen und verschachtelten Objekten.

Beispiel eines JSON-Prüfberichts

{
  "datensatz": "Fiktive Ausbildungsdaten",
  "anzahl": 4,
  "mittelwert_v": 11.8,
  "auffaellige_ids": ["P-103"]
}

Im Unterschied zur CSV-Datei enthält JSON hier einen zusammenfassenden Prüfbericht statt einzelner Tabellenzeilen.

Lokales Miniprogramm: JSON schreiben und lesen

import json
from io import StringIO

bericht = {
    "anzahl": 4,
    "pruefen": 1
}

datei = StringIO()

json.dump(bericht, datei, indent=2)
datei.seek(0)

eingelesen = json.load(datei)

print(eingelesen["pruefen"])

Erwartete Ausgabe:

Merke:

`json.dump()` schreibt Daten in ein geöffnetes Dateiobjekt. `json.load()` liest sie daraus. `json.dumps()` und `json.loads()` arbeiten dagegen direkt mit Zeichenketten.

Lernvideos: JSON

Computerphile: JSON, not Jason (englisch). Einführung in den Datenaustausch mit JSON.

Corey Schafer: Working with JSON Data using the json Module (englisch).

Anwendungsaufgabe: Ergänze im JSON-Beispiel den Schlüssel `werkstatt` mit dem Wert `Lernwerkstatt`. Prüfe, ob das Einlesen weiterhin funktioniert.

Feedback: Nach dem erneuten Einlesen muss der neue Schlüssel abrufbar sein. Ein fehlendes Komma kann JSON ungültig machen.

Lerneinheit 3: Daten prüfen und auswerten

Dauer: ca. 20 Minuten

Vor der Berechnung werden Daten gegen ein vereinbartes Datenschema geprüft.

In unserem Ausbildungsfall gelten folgende Regeln:

Datenformat: Die CSV-Datei hat die Spalten `id` und `spannung_v`.
Datentyp: Der Messwert muss als endliche Zahl interpretierbar sein.
Eindeutigkeit: Jede Prüflings-ID darf nur einmal vorkommen.
Plausibilitätsprüfung: Fehlende oder nicht interpretierbare Daten führen zu einem Fehler.
Toleranz: Werte von 11,5 bis 12,5 V einschließlich gelten als OK.

Eine technische Entscheidung programmieren

spannung = 10.8
minimum = 11.5
maximum = 12.5

if minimum <= spannung <= maximum:
    status = "OK"
else:
    status = "PRUEFEN"

print(status)

Erwartete Ausgabe:

PRUEFEN

Begründung: 10,8 V liegt unter der unteren Grenze von 11,5 V.

Die Bewertung bedeutet ausschließlich, dass ein fiktiver Datenwert außerhalb des vorgegebenen Übungsbereichs liegt. Sie ersetzt keine reale elektrische Prüfung.

Gestufte Hilfe

Stufe	Hilfe
Hilfe 1	Überlege, welche beiden Grenzen ein Messwert erfüllen muss.
Hilfe 2	Verwende einen logischen Vergleich mit `<=`.
Hilfe 3	Nutze `minimum <= spannung <= maximum` und überprüfe beide Grenzwerte.

Lerneinheit 4: Vollständiges Praxisprojekt

Dauer: ca. 35 Minuten

Fehler beim Erstellen des Vorschaubildes:

Jetzt verbindest Du alle Schritte.

Vorbereitung: Speichere den folgenden Quelltext als `pruefstation.py` in Deiner lokalen Übungsumgebung.

Ausführung: Öffne ein lokales Terminal und starte das Programm mit `python3 pruefstation.py`. Unter Windows kann abhängig von der Installation auch `py -3 pruefstation.py` verwendet werden.

Das Programm erzeugt seine Eingabe selbst. Es liest keine fremden Dateien ein, verwendet keine Netzwerkfunktionen und überschreibt keine vorhandenen Projektdateien.

Vollständig lauffähiges Python-Programm

import csv
import json
import math
import tempfile
from pathlib import Path

ROHDATEN = [
    ("P-101", "11.9"),
    ("P-102", "12.3"),
    ("P-103", "10.8"),
    ("P-104", "12.2"),
]

MIN_V, MAX_V = 11.5, 12.5

with tempfile.TemporaryDirectory(
    prefix="aimooc_pruefstation_"
) as tmp:
    ordner = Path(tmp)
    quelle = ordner / "messwerte.csv"

    # CSV mit fiktiven Werten erzeugen
    with quelle.open(
        "w", encoding="utf-8", newline=""
    ) as datei:
        schreiber = csv.writer(datei, delimiter=";")
        schreiber.writerow(["id", "spannung_v"])
        schreiber.writerows(ROHDATEN)

    # CSV strukturiert einlesen und validieren
    messungen = []

    with quelle.open(
        "r", encoding="utf-8", newline=""
    ) as datei:
        leser = csv.DictReader(datei, delimiter=";")

        if leser.fieldnames != ["id", "spannung_v"]:
            raise ValueError("Unerwartete CSV-Kopfzeile")

        for zeile in leser:
            if (
                None in zeile
                or zeile["id"] is None
                or zeile["spannung_v"] is None
            ):
                raise ValueError("Falsche Spaltenzahl")

            ident = zeile["id"].strip()

            if not ident:
                raise ValueError("Leere Prueflings-ID")

            try:
                wert = float(zeile["spannung_v"])
            except (TypeError, ValueError) as fehler:
                raise ValueError(
                    f"Ungueltiger Messwert bei {ident}"
                ) from fehler

            if not math.isfinite(wert):
                raise ValueError(
                    f"Kein endlicher Messwert bei {ident}"
                )

            messungen.append({
                "id": ident,
                "spannung_v": wert
            })

    ids = [m["id"] for m in messungen]

    if not ids or len(ids) != len(set(ids)):
        raise ValueError(
            "Keine Messungen oder doppelte IDs"
        )

    # Fachliche Auswertung
    ergebnisse = [
        {
            **m,
            "status": (
                "OK"
                if MIN_V <= m["spannung_v"] <= MAX_V
                else "PRUEFEN"
            )
        }
        for m in messungen
    ]

    # Ergebnis als CSV speichern
    bericht_csv = ordner / "pruefbericht.csv"

    with bericht_csv.open(
        "w", encoding="utf-8", newline=""
    ) as datei:
        schreiber = csv.DictWriter(
            datei,
            fieldnames=[
                "id", "spannung_v", "status"
            ],
            delimiter=";"
        )
        schreiber.writeheader()
        schreiber.writerows(ergebnisse)

    # Zusammenfassung erstellen
    bericht = {
        "datensatz": "Fiktive Ausbildungsdaten",
        "grenzen_v": {
            "min": MIN_V,
            "max": MAX_V
        },
        "anzahl": len(ergebnisse),
        "mittelwert_v": round(
            sum(
                m["spannung_v"]
                for m in messungen
            ) / len(messungen),
            2
        ),
        "auffaellige_ids": [
            e["id"]
            for e in ergebnisse
            if e["status"] == "PRUEFEN"
        ]
    }

    # JSON-Datei schreiben
    bericht_json = ordner / "pruefbericht.json"

    with bericht_json.open(
        "w", encoding="utf-8"
    ) as datei:
        json.dump(
            bericht,
            datei,
            ensure_ascii=False,
            indent=2,
            allow_nan=False
        )

    # JSON-Datei zur Kontrolle wieder einlesen
    with bericht_json.open(
        "r", encoding="utf-8"
    ) as datei:
        kontrolle = json.load(datei)

    assert kontrolle["anzahl"] == 4
    assert kontrolle["auffaellige_ids"] == ["P-103"]

    print("ERGEBNIS-CSV")
    print(
        bericht_csv.read_text(
            encoding="utf-8"
        ).strip()
    )

    print("ERGEBNIS-JSON")
    print(
        bericht_json.read_text(
            encoding="utf-8"
        )
    )

    ok = sum(
        e["status"] == "OK"
        for e in ergebnisse
    )
    pruefen = len(ergebnisse) - ok

    print(f"OK       {'█' * ok} ({ok})")
    print(
        f"PRUEFEN  {'█' * pruefen} ({pruefen})"
    )

Erklärung: `TemporaryDirectory` erstellt einen temporären Übungsordner. Die Dateien werden während der Programmausführung tatsächlich geschrieben und wieder gelesen. Nach Verlassen des `with`-Blocks wird der Ordner automatisch entfernt.

Hinweis: Bei schwerwiegenden Systemabbrüchen kann eine automatische Bereinigung ausbleiben. Dies ist eine isolierte Lernübung, keine vollständige Sicherheitsarchitektur für Produktivsoftware.

Erwartetes CSV-Ergebnis

id;spannung_v;status
P-101;11.9;OK
P-102;12.3;OK
P-103;10.8;PRUEFEN
P-104;12.2;OK

Erwartetes JSON-Ergebnis

{
  "datensatz": "Fiktive Ausbildungsdaten",
  "grenzen_v": {
    "min": 11.5,
    "max": 12.5
  },
  "anzahl": 4,
  "mittelwert_v": 11.8,
  "auffaellige_ids": [
    "P-103"
  ]
}

Kontrollfrage: Warum enthält die Ergebnis-CSV alle Prüflinge, während `auffaellige_ids` nur P-103 enthält?

Begründetes Feedback: Die CSV dokumentiert sämtliche Einzelergebnisse. Das JSON-Feld `auffaellige_ids` ist dagegen eine gezielte Zusammenfassung der Werte außerhalb des vereinbarten Übungsbereichs.

Lerneinheit 5: Daten visualisieren

Dauer: ca. 10 Minuten

Fehler beim Erstellen des Vorschaubildes:

Die Abbildung ist ein allgemeines Diagrammsymbol. Das folgende Diagramm zeigt die tatsächlichen Ergebnisse unserer fiktiven Übung.

Ergebnisübersicht

Fiktive Prüflinge: 4

OK       ███  3
PRÜFEN   █    1

OK-Anteil: 75 %
Prüfanteil: 25 %
Mittelwert: 11,8 V

Kennzahl	Ergebnis	Bedeutung
Datensätze	4	Alle eingelesenen Prüflinge
Im Übungsbereich	3	Spannungen von 11,5 bis 12,5 V
Außerhalb	1	Zusätzliche Prüfung erforderlich
Mittelwert	11,8 V	Arithmetischer Durchschnitt

Transferfrage: Würdest Du den gesamten Übungsdatensatz allein aufgrund des Mittelwerts als unauffällig bewerten?

Feedback: Nein. Der Mittelwert liegt zwar innerhalb des Übungsbereichs, aber ein einzelner Messwert liegt darunter. Einzelwerte und zusammenfassende Kennzahlen beantworten unterschiedliche Fragen.

Lerneinheit 6: Isolierte Tests und Fehlersuche

Dauer: ca. 25 Minuten

Eine Testumgebung soll kontrollierbare Eingaben und eindeutig erwartete Ergebnisse besitzen.

Hier verwendest Du `StringIO` als Datei-Ersatz im Arbeitsspeicher. Es gibt keine Verbindung zu Anlagen, externen Diensten oder fremden Dateisystemen.

Lokales Testlabor

Speichere das folgende Programm als `testlabor.py`. Starte es lokal mit `python3 testlabor.py`.

import csv
import math
from io import StringIO

def pruefe(csv_text):
    leser = csv.DictReader(
        StringIO(csv_text),
        delimiter=";"
    )

    if leser.fieldnames != ["id", "spannung_v"]:
        return "FEHLER: Kopfzeile"

    zeilen = list(leser)

    if len(zeilen) != 1 or None in zeilen[0]:
        return "FEHLER: Zeilenzahl"

    try:
        wert = float(zeilen[0]["spannung_v"])
    except (TypeError, ValueError):
        return "FEHLER: Messwert"

    if not math.isfinite(wert):
        return "FEHLER: Messwert"

    return (
        "OK"
        if 11.5 <= wert <= 12.5
        else "PRUEFEN"
    )

TESTS = [
    (
        "id;spannung_v\nX-1;11.5\n",
        "OK"
    ),
    (
        "id;spannung_v\nX-2;12.6\n",
        "PRUEFEN"
    ),
    (
        "id;spannung_v\nX-3;abc\n",
        "FEHLER: Messwert"
    ),
    (
        "kennung;spannung_v\nX-4;12.0\n",
        "FEHLER: Kopfzeile"
    ),
    (
        "id;spannung_v\nX-5;NaN\n",
        "FEHLER: Messwert"
    )
]

for nummer, (eingabe, erwartet) in enumerate(TESTS, 1):
    aktuell = pruefe(eingabe)

    ergebnis = (
        "BESTANDEN"
        if aktuell == erwartet
        else "FEHLER"
    )

    print(
        f"Test {nummer}: {aktuell} -> {ergebnis}"
    )

    assert aktuell == erwartet

Erwartete Ausgabe:

Test 1: OK -> BESTANDEN
Test 2: PRUEFEN -> BESTANDEN
Test 3: FEHLER: Messwert -> BESTANDEN
Test 4: FEHLER: Kopfzeile -> BESTANDEN
Test 5: FEHLER: Messwert -> BESTANDEN

Begründetes Testfeedback

Test	Erwartung	Erklärung
Unterer Grenzwert	OK	Der Grenzwert gehört ausdrücklich zum zulässigen Intervall.
Oberhalb des Intervalls	PRUEFEN	12,6 V überschreitet die festgelegte obere Grenze.
Text statt Zahl	Fehlermeldung	Ein nicht numerischer Messwert darf keine fachliche Bewertung erhalten.
Falsche Kopfzeile	Fehlermeldung	Die erwartete Datenstruktur muss eingehalten werden.
NaN	Fehlermeldung	Ein nicht endlicher Zahlenwert ist keine gültige Messung.

Interaktive lokale Übung: Ändere nacheinander die Zeichenketten in `TESTS`, formuliere zuerst das erwartete Ergebnis und führe das Programm erneut aus.

Wichtig: Das Testlabor kontrolliert bewusst nur einen einzelnen CSV-Datensatz pro Test. Das vollständige Praxisprogramm übernimmt zusätzlich die Prüfung eindeutiger IDs und die Verarbeitung mehrerer Datensätze.

Gestufte Hilfen für die Fehlersuche

Problem	Erste Hilfe	Zweite Hilfe	Dritte Hilfe
Falscher CSV-Wert	Prüfe die Kopfzeile.	Prüfe das Trennzeichen.	Vergleiche die Feldnamen mit `DictReader`.
Ungültige Zahl	Untersuche den Eingabetext.	Teste `float()`.	Fange `ValueError` ab und prüfe `math.isfinite()`.
Falscher Prüfstatus	Prüfe die Grenzwerte.	Kontrolliere die Vergleichsoperatoren.	Teste die unteren und oberen Randwerte getrennt.
JSON-Fehler	Prüfe Schlüssel und Werte.	Kontrolliere den Datentyp.	Vergleiche das Ergebnis nach `json.load()` mit der erwarteten Struktur.

Technische Qualität und Datenschutz

Fehler beim Erstellen des Vorschaubildes:

Für nachvollziehbare Datenverarbeitung sind folgende Regeln wesentlich:

Zeichenkodierung: Verwende eine ausdrücklich festgelegte Kodierung wie UTF-8.
CSV: Gib Trennzeichen und Feldnamen vor; beim CSV-Dateizugriff verwende `newline=""`.
Validierung: Prüfe Spaltenanzahl, Datentypen, endliche Zahlen und eindeutige Kennungen.
JSON: Verwende bei Bedarf `ensure_ascii=False`, `indent=2` und `allow_nan=False`.
Testdaten: Nutze künstliche Datensätze ohne Personen- oder Kundendaten.
Datensicherheit: Arbeite nur mit autorisierten lokalen Übungsdateien und niemals ungefragt mit Produktivsystemen.
Nachvollziehbarkeit: Dokumentiere Grenzwerte, Einheit, Herkunft, Regeln und erwartete Ergebnisse.

Bei einer späteren Tabellenkalkulationsanbindung ist zusätzlich auf mögliche Interpretation von Zellinhalten als Formeln zu achten. Fremde Texte dürfen nicht ungeprüft übernommen werden.

Interaktive Aufgaben

Quiz: Teste Dein Wissen

Was beschreibt das CSV-Format am besten? (Tabellarisch strukturierte Textdaten) (!Ein ausführbares Maschinenprogramm) (!Ein ausschließlich binäres Bildformat) (!Eine verschlüsselte Datenbank)

Welches Python-Werkzeug liest CSV-Zeilen anhand ihrer Spaltennamen? (csv.DictReader) (!json.dump) (!math.isfinite) (!tempfile.TemporaryDirectory)

Welches Trennzeichen wird im Praxisbeispiel für CSV verwendet? (Semikolon) (!Doppelpunkt) (!Ausrufezeichen) (!Schrägstrich)

Warum wird ein CSV-Messwert mit float umgewandelt? (Damit numerische Vergleiche und Berechnungen möglich werden) (!Damit automatisch ein Diagramm entsteht) (!Damit die Datei verschlüsselt wird) (!Damit der Messwert gelöscht wird)

Wozu dient json.dump in unserem Praxisprojekt? (Zum Schreiben strukturierter Daten in eine JSON-Datei) (!Zum Einlesen einer CSV-Kopfzeile) (!Zum Messen einer elektrischen Spannung) (!Zum Starten eines Netzwerkservers)

Welche Bewertung erhält im Übungsfall eine Spannung von 10,8 Volt? (PRUEFEN) (!OK) (!NICHT GEMESSEN) (!DATEI FEHLT)

Warum wird eine CSV-Datei mit newline gleich leerer Zeichenkette geöffnet? (Damit das CSV-Modul Zeilenenden korrekt behandeln kann) (!Damit alle Datensätze gelöscht werden) (!Damit Zahlen automatisch sortiert werden) (!Damit JSON erzeugt wird)

Was geschieht normalerweise nach dem Verlassen eines TemporaryDirectory-Kontextes? (Das temporäre Verzeichnis und sein Inhalt werden entfernt) (!Die Messwerte werden ins Internet übertragen) (!Das Betriebssystem wird neu gestartet) (!Die Dateien werden automatisch veröffentlicht)

Warum muss ein NaN-Messwert vor der fachlichen Bewertung zurückgewiesen werden? (Weil er keinen gültigen endlichen Messwert darstellt) (!Weil er immer größer als der obere Grenzwert ist) (!Weil jede Zeichenkette ein gültiger Messwert ist) (!Weil JSON keine Schlüssel erlaubt)

Was belegt ein bestandener lokaler Test? (Dass das Programm für den jeweiligen Testfall die Erwartung erfüllt) (!Dass das Programm unter allen Bedingungen fehlerfrei ist) (!Dass jede denkbare Produktionsanlage sicher betrieben werden kann) (!Dass keine weiteren Tests erforderlich sind)

Memory

CSV	Tabellarisches Austauschformat
JSON	Format für strukturierte Objekte und Listen
DictReader	Einlesen anhand von Spaltennamen
DictWriter	Schreiben anhand von Spaltennamen
UTF-8	Zeichenkodierung für Unicode
TemporaryDirectory	Automatisch bereinigter Übungsordner
Validierung	Prüfung gegen festgelegte Datenregeln
StringIO	Textdatei-Ersatz im Arbeitsspeicher

Drag and Drop

Ordne die richtigen Begriffe zu.	Aufgabe im Datenprozess
Einlesen	Strukturierte CSV-Quelle verarbeiten
Validieren	Feldnamen und Messwerte prüfen
Auswerten	Prüfstatus aus Grenzwerten ableiten
Speichern	Ergebnisdateien in CSV und JSON erzeugen
Kontrollieren	Gespeichertes Ergebnis erneut lesen

Kreuzworträtsel

Kopfzeile	Wie heißt die erste CSV-Zeile mit den Feldnamen?
Trennzeichen	Was trennt die Spalten einer CSV-Datei?
Parser	Wie nennt man ein Programmteil zur Interpretation strukturierter Eingaben?
Validierung	Wie heißt die Prüfung von Daten gegen festgelegte Regeln?
Verzeichnis	Wie heißt ein Ordner im Dateisystem fachsprachlich?
Serialisierung	Wie heißt das Umwandeln von Datenstrukturen in ein Speicherformat?

LearningApps

Optionales externes Suchangebot für Lernübungen. Die Ergebnisse sind keine speziell für diesen Kurs geprüften Anwendungen. Gib dort keine persönlichen oder betrieblichen Daten ein. Die Python-Testumgebungen dieses Kurses bleiben lokal.

Lückentext

Im Ausbildungsfall werden ausschließlich

Messdaten verwendet.

Das tabellarische Austauschformat heißt

.

Die erste Zeile mit den Feldnamen nennt man

.

Die Felder unseres Beispiels werden durch ein

getrennt.

Mit csv.DictReader werden Werte anhand ihrer

gelesen.

Die Umwandlung einer Zahlenzeichenkette erfolgt mit

.

Die Prüfung vor einer fachlichen Auswertung heißt

.

Strukturierte Prüfberichte können im Format

gespeichert werden.

Die Funktion zum Schreiben eines JSON-Objekts in eine Datei heißt json.

.

Die Funktion zum Einlesen eines JSON-Dokuments aus einer Datei heißt json.

.

Für die isolierte Dateiverarbeitung verwenden wir ein temporäres

.

Ein automatischer Vergleich zwischen tatsächlichem und erwartetem Ergebnis ist ein

.

Offene Aufgaben

Bearbeite die Aufgaben nur mit erfundenen Übungsdaten. Nutze bei Bedarf die gestuften Hilfen aus den Lerneinheiten.

Leicht

Basisaufgaben

CSV-Tabelle erstellen: Erstelle einen eigenen fiktiven Datensatz mit fünf Prüflingen. Verwende eindeutige IDs und Spannungswerte. Feedbackkriterium: Jede Zeile hat dieselben Felder und das festgelegte Trennzeichen.
CSV-Zeilen ausgeben: Ergänze das erste Miniprogramm um eine weitere erfundene Messung. Feedbackkriterium: Alle IDs und Werte erscheinen korrekt; andernfalls prüfe die Feldnamen.
Prüfbericht erweitern: Ergänze im JSON-Beispiel eine eigene Werkstattbezeichnung und eine Versionsnummer. Feedbackkriterium: Beide Werte bleiben nach dem Schreiben und Einlesen erhalten.
Datenfluss zeichnen: Zeichne den Ablauf vom CSV-Eingang bis zum JSON-Ergebnis. Feedbackkriterium: Eingabe, Prüfung, Verarbeitung und Ausgabe sind unterscheidbar.

Standard

Anwendungsaufgaben

Messwerte kontrollieren: Erweitere das lokale Testlabor um leere und besonders große Zahlenwerte. Feedbackkriterium: Nicht interpretierbare oder nicht endliche Werte werden begründet zurückgewiesen.
Grenzwerte verändern: Ändere im vollständigen Übungsprogramm die Grenzen auf 11,8 bis 12,2 V und ermittle den neuen Prüfstatus. Feedbackkriterium: P-102 und P-103 sind nun auffällig, weil beide außerhalb des neuen Bereichs liegen.
Eigene Ergebnisgrafik: Erstelle für mindestens sechs fiktive Prüflinge eine textbasierte Balkengrafik der Statushäufigkeiten. Feedbackkriterium: Summe der Balkenwerte und Zahl der eingelesenen Datensätze stimmen überein.
Fehlerbericht erstellen: Formuliere vier Testfälle mit Eingabe, erwarteter Ausgabe, tatsächlicher Ausgabe und Begründung. Feedbackkriterium: Jeder Fall ist reproduzierbar und besitzt ein prüfbares Ergebnis.

Schwer

Transferaufgaben

Mehrere Messgrößen: Erweitere den fiktiven Datensatz um eine zweite Messgröße mit eigener Einheit und eigenem Toleranzbereich. Feedbackkriterium: Beide Eigenschaften werden unabhängig validiert; ihre Grenzen sind dokumentiert.
Formatschnittstelle entwickeln: Entwirf ein JSON-Schema auf fachlicher Ebene, mit dem eine andere Lernanwendung den Prüfbericht verstehen könnte. Feedbackkriterium: Feldnamen, Typen, Einheiten, Versionsnummer und Pflichtfelder sind eindeutig definiert.
Robuste Verarbeitung: Überarbeite das Praxisprogramm so, dass fehlerhafte Datensätze in einer gesonderten lokalen Fehlerliste dokumentiert werden, ohne sie als gültige Messung zu zählen. Feedbackkriterium: Gültige, ungültige und insgesamt gelesene Datensätze bleiben nachvollziehbar.
Prüfprozess bewerten: Entwickle eine Präsentation oder ein kurzes Erklärvideo über Vorteile und Grenzen automatisierter Messdatenauswertung. Nutze ausschließlich simulierte Beispiele. Feedbackkriterium: Du unterscheidest nachvollziehbar zwischen rechnerischer Auswertung, Datenqualität und tatsächlicher technischer Sicherheit.

Lernkontrolle

Bei diesen Aufgaben steht die Anwendung im Mittelpunkt, nicht das reine Wiedergeben von Fachbegriffen.

Datenqualität: Erkläre anhand eines eigenen fiktiven Beispiels, weshalb eine fehlerhafte CSV-Kopfzeile trotz vorhandener Zahlen zu unzuverlässigen Ergebnissen führen kann.
Programmierung: Untersuche, welche Auswirkungen eine Änderung der Toleranzgrenzen auf Einzelergebnisse, Fehleranzahl und JSON-Zusammenfassung hat.
Statistik: Entwickle ein Beispiel, in dem der Durchschnitt innerhalb des zulässigen Bereichs liegt, obwohl mehrere Einzelwerte außerhalb liegen, und erläutere die Konsequenzen.
Softwaretest: Begründe, warum erfolgreiche Tests mit normalen Messwerten allein nicht ausreichen und welche Grenz- und Fehlerfälle ergänzt werden müssen.
Datenmodellierung: Entscheide für einen neuen technischen Übungsfall, welche Informationen in einer CSV-Tabelle und welche in einem JSON-Bericht besser aufgehoben sind.
Datensicherheit: Entwirf einen sicheren Weg, mit dem ein Lernprogramm später auf ausdrücklich freigegebene Testdateien umgestellt werden könnte, ohne unkontrollierten Zugriff auf Produktivdaten zu ermöglichen.

Lernnachweis

Für einen erfolgreichen Lernnachweis erstellst Du eine kleine technische Projektdokumentation mit folgenden Bestandteilen:

Projektbeschreibung: Beschreibe den fiktiven Ausbildungsfall und die vereinbarten fachlichen Grenzen.
Datenstruktur: Lege das CSV-Eingabeformat und die JSON-Ausgabestruktur eindeutig fest.
Quellcode: Gib ein lokal lauffähiges Programm mit nachvollziehbaren Verarbeitungsschritten ab.
Validierung: Zeige, wie fehlerhafte und fehlende Daten erkannt werden.
Testergebnis: Dokumentiere mindestens fünf unterschiedliche Testfälle mit erwarteten und tatsächlichen Ergebnissen.
Visualisierung: Stelle die Ergebnisse übersichtlich als Tabelle oder Diagramm dar.
Reflexion: Begründe Deine Formatwahl und beschreibe Grenzen der automatisierten Auswertung.
Sicherheitsnachweis: Bestätige, dass ausschließlich künstliche Daten und eine autorisierte lokale Testumgebung verwendet wurden.

Bewertungsvorschlag:

Kompetenz	Anteil
Fachlich korrekte Verarbeitung	30 %
Verständliche Datenstruktur	20 %
Validierung und Testfälle	25 %
Nachvollziehbare Darstellung	15 %
Sichere Arbeitsweise und Reflexion	10 %

Bestehensmaßstab: Das Programm muss mit dem vorgegebenen fiktiven Datensatz funktionieren. Kritische Fehler, beispielsweise unerkannte ungültige Messwerte oder die Verwendung nicht autorisierter Daten, müssen behoben werden.

OERs zum Thema

Wikipedia: CSV

Wikipedia: JSON

Fachlich geprüfte Referenzen

Python-Dokumentation: csv – Einlesen und Schreiben von CSV, Trennzeichen, DictReader und DictWriter.
Python-Dokumentation: json – Serialisierung, Einlesen, Schreiben und Formatierung.
Python-Dokumentation: tempfile – Temporäre Dateien und Verzeichnisse.
RFC 4180 – Dokumentation eines gebräuchlichen CSV-Formats.
RFC 8259 – Technische Spezifikation des JSON-Formats.

Mediennachweise und Nutzungsrechte

Die folgenden verwendeten Dateien wurden auf Wikimedia Commons mit ihren jeweiligen Lizenzangaben recherchiert:

Python-logo-notext.svg – Python-Logo, gemeinfreie einfache geometrische Darstellung laut Commons; mögliche Markenrechte beachten.
Generic Folder.svg – The People's Internet, CC0 1.0.
File folder icon.svg – Dodgoranio662, CC0 1.0.
Csv ikon.svg – Dreftymac, bearbeitet durch Zerind, CC BY-SA 2.5.
JSON vector logo.svg – Douglas Crockford, gemeinfreies Text-/Formlogo laut Commons; mögliche Markenrechte beachten.
Extract, Transform, Load Data Flow Diagram.svg – Bamyers99, CC0 1.0.
Data-flow-diagram-example.svg – AutumnSnow auf Grundlage einer Arbeit von Ilario, unter anderem CC BY-SA 3.0.
Flowchart icon.svg – OfficialURL, CC0 1.0.
Bar chart – Nice and Serious, CC0 1.0.

Hinweis zur Nachnutzung: Bei Dateien unter CC BY-SA sind Urheberangabe, Lizenzlink und gegebenenfalls Bearbeitungshinweis erforderlich. Die verlinkten Dateibeschreibungsseiten enthalten die maßgeblichen Lizenzangaben.

Die eingebundenen YouTube-Videos stammen von Corey Schafer und Computerphile. Sie sind externe Lernmedien und werden nicht pauschal als frei lizenzierte OER eingestuft. Eine Weiterverbreitung oder Bearbeitung der Videos erfordert eine entsprechend geklärte Berechtigung. Für den Offline-Betrieb sind die lokalen Python-Beispiele ausreichend.

Die textbasierten Diagramme und der fiktive Ausbildungsdatensatz wurden speziell für diesen Kurs erstellt.

Verknüpfte Lernbereiche

Programmieren für technische Aufgaben

Weiterführende Themen

Algorithmen: Daten mit nachvollziehbaren Regeln verarbeiten.
Objektorientierte Programmierung: Größere Programme in Komponenten strukturieren.
SQL: Tabellarische Daten in Datenbanken verwalten.
Messdatenerfassung: Technische Messgrößen systematisch erfassen.
Versionsverwaltung: Änderungen am Quellcode dokumentieren.
Automatisierungstechnik: Datenverarbeitung von realen Anlagenprozessen unterscheiden.