Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 1: Syntax kompakt – wc

Ziel: Strings, Listen, Dicts, Schleifen und Comprehensions an einem eigenen wc üben, das Zeilen, Wörter, Zeichen und die häufigsten Wörter zählt · Dauer: ca. 90 min · Voraussetzung: Tag 0

Briefing

  • Strings sind unveränderlich und Unicode: len("Prüfe") ist 5, egal wie viele Bytes.
  • list, dict, set, tuple sind die Arbeitspferde; collections.Counter zählt für dich.
  • Comprehensions ([x for x in ...]) ersetzen die meisten Schleifen mit append.
  • Am Ende vergleichst du dein Tool per diff mit dem wc von macOS – Byte für Byte.
Datei/stdin ──► read_text() ──► count()      ──► "       5      31     209 datei"
                            └─► top_words()  ──► Counter.most_common(n)

Drill 1: Projekt und Testtext

cd ~/py-lab
uv init -q --package --name wc tag01-wc
cd tag01-wc
uv add -q --dev pytest ruff
mkdir -p lab
cat > lab/runbook.txt <<'EOF'
Runbook: Zertifikat erneuern

Prüfe das Zertifikat. Prüfe die Kette, dann prüfe den Ablauf.
Erneuere das Zertifikat rechtzeitig, sonst fällt der Dienst aus.
Der Dienst meldet Fehler; die Fehler landen im Log.
EOF
/usr/bin/wc lab/runbook.txt
/usr/bin/wc -lwm lab/runbook.txt

Erwartet:

       5      31     213 lab/runbook.txt
       5      31     209 lab/runbook.txt

Warum zwei Werte? wc zählt ohne Option Bytes, mit -m Zeichen. Die vier Umlaute brauchen in UTF-8 je zwei Bytes. Dein Tool wird Zeichen zählen, also vergleichst du später mit wc -lwm.

Tipp: /usr/bin/wc mit vollem Pfad: Innerhalb von uv run liegt .venv/bin vorne im PATH, dort wohnt bald dein eigenes wc.

Fortschritt speichern? Kostenlos registrieren

Drill 2: Strings

uv run python - <<'EOF'
zeile = "  Prüfe das Zertifikat. Prüfe die Kette!  "
print(repr(zeile.strip()))
print(zeile.split())
print(zeile.lower().count("prüfe"))
wort = "Zertifikat."
print(wort.strip(".,;:!?"), wort[:4], wort[-1], len(wort))
print(f"{'Zeilen':<8}|{42:>8}|{3.14159:.2f}")
EOF

Erwartet:

'Prüfe das Zertifikat. Prüfe die Kette!'
['Prüfe', 'das', 'Zertifikat.', 'Prüfe', 'die', 'Kette!']
2
Zertifikat Zert . 11
Zeilen  |      42|3.14
  • split() ohne Argument trennt an beliebigem Whitespace und wirft leere Teile weg – genau das, was wc unter „Wort” versteht.
  • strip(".,;:!?") entfernt jedes der Zeichen an beiden Enden, nicht die Zeichenkette als Ganzes.
  • Slicing [:4], [-1] funktioniert bei Strings, Listen und Tupeln gleich.
  • Im f-String steuert :<8 / :>8 die Ausrichtung, :.2f die Nachkommastellen.

Fortschritt speichern? Kostenlos registrieren

Drill 3: Listen und Schleifen

uv run python - <<'EOF'
from pathlib import Path

text = Path("lab/runbook.txt").read_text(encoding="utf-8")
lines = text.splitlines()
print(type(lines), len(lines))
print(lines[0], "|", lines[-1])
words = 0
for nr, line in enumerate(lines, start=1):
    n = len(line.split())
    words += n
    print(f"{nr:>2}: {n:>2} Wörter")
print("Summe:", words, "Zeichen:", len(text), "Newlines:", text.count("\n"))
EOF

Erwartet:

<class 'list'> 5
Runbook: Zertifikat erneuern | Der Dienst meldet Fehler; die Fehler landen im Log.
 1:  3 Wörter
 2:  0 Wörter
 3: 10 Wörter
 4:  9 Wörter
 5:  9 Wörter
Summe: 31 Zeichen: 209 Newlines: 5

Warum enumerate? Es liefert Index und Wert zugleich; ein for i in range(len(lines)) wie in C ist in Python ein Stilfehler. encoding="utf-8" immer explizit angeben – der Default hängt sonst von der Plattform ab.

Fortschritt speichern? Kostenlos registrieren

Drill 4: Dicts und Counter

uv run python - <<'EOF'
from collections import Counter
from pathlib import Path

words = Path("lab/runbook.txt").read_text(encoding="utf-8").lower().split()
counts: dict[str, int] = {}
for w in words:
    w = w.strip(".,;:!?")
    counts[w] = counts.get(w, 0) + 1
print(counts["prüfe"], counts.get("vault", 0))
top = sorted(counts.items(), key=lambda kv: kv[1], reverse=True)[:3]
print(top)
print(Counter(w.strip(".,;:!?") for w in words).most_common(3))
EOF

Erwartet:

3 0
[('zertifikat', 3), ('prüfe', 3), ('das', 2)]
[('zertifikat', 3), ('prüfe', 3), ('das', 2)]
  • counts["vault"] würde mit KeyError abbrechen; get(key, 0) liefert den Default.
  • items() gibt (key, value)-Tupel; sorted(..., key=...) sortiert nach dem zweiten Element.
  • Counter erledigt Zählen und Sortieren in einer Zeile. Dicts behalten die Einfügereihenfolge, deshalb ist das Ergebnis stabil.

Fortschritt speichern? Kostenlos registrieren

Drill 5: Comprehensions

uv run python - <<'EOF'
from pathlib import Path

STOP = {"der", "die", "das", "dann", "sonst", "im"}
raw = Path("lab/runbook.txt").read_text(encoding="utf-8").lower().split()
words = [w.strip(".,;:!?") for w in raw]
print(words[:6])
meaningful = [w for w in words if len(w) > 2 and w not in STOP]
print(meaningful[:6])
unique = {w for w in meaningful}
print(len(words), len(meaningful), len(unique))
lengths = {w: len(w) for w in sorted(unique) if len(w) > 9}
print(lengths)
print(sum(1 for w in words if w.startswith("z")))
EOF

Erwartet:

['runbook', 'zertifikat', 'erneuern', 'prüfe', 'das', 'zertifikat']
['runbook', 'zertifikat', 'erneuern', 'prüfe', 'zertifikat', 'prüfe']
31 22 16
{'rechtzeitig': 11, 'zertifikat': 10}
3
Form Ergebnis Beispiel
[...] Liste [w.lower() for w in words]
{...} Set {w for w in words}
{k: v ...} Dict {w: len(w) for w in words}
(...) Generator (lazy) sum(1 for w in words if ...)

Warum ein Set für Stoppwörter? w not in STOP ist bei einem Set O(1), bei einer Liste O(n). Der Generator in sum(...) baut keine Zwischenliste – bei großen Dateien spart das Speicher.

Fortschritt speichern? Kostenlos registrieren

Drill 6: Das Werkzeug

Jetzt kommt alles in das Paket. argparse liefert Optionen, Hilfe und Fehlermeldungen; ab Tag 3 übernimmt typer.

cat > src/wc/__init__.py <<'EOF'
"""wc – Zeilen, Wörter und Zeichen zählen, dazu die häufigsten Wörter."""

import argparse
import sys
from collections import Counter
from pathlib import Path

PUNCT = ".,;:!?()[]\"'"
STOPWORDS = {"der", "die", "das", "und", "oder", "dann", "sonst", "im", "the", "and"}


def count(text: str) -> tuple[int, int, int]:
    """Zeilen (Anzahl Newlines wie bei wc), Wörter, Zeichen."""
    return text.count("\n"), len(text.split()), len(text)


def top_words(text: str, n: int = 5) -> list[tuple[str, int]]:
    """Die n häufigsten Wörter, ohne Satzzeichen, Stoppwörter und Kurzwörter."""
    words = [w.strip(PUNCT) for w in text.lower().split()]
    kept = [w for w in words if len(w) > 2 and w not in STOPWORDS]
    return Counter(kept).most_common(n)


def fmt(values: tuple[int, ...], show: list[bool], name: str = "") -> str:
    """Spalten wie BSD-wc: je 8 Zeichen rechtsbündig, dann der Name."""
    cols = "".join(f"{v:>8}" for v, on in zip(values, show, strict=True) if on)
    return f"{cols} {name}".rstrip()


def main(argv: list[str] | None = None) -> int:
    parser = argparse.ArgumentParser(prog="wc", description="Zeilen/Wörter/Zeichen")
    parser.add_argument("files", nargs="*", type=Path, help="Dateien (ohne: stdin)")
    parser.add_argument("-l", "--lines", action="store_true", help="Zeilen zählen")
    parser.add_argument("-w", "--words", action="store_true", help="Wörter zählen")
    parser.add_argument("-m", "--chars", action="store_true", help="Zeichen zählen")
    parser.add_argument("--top", type=int, default=0, metavar="N", help="Top-N-Wörter")
    args = parser.parse_args(argv)

    show = [args.lines, args.words, args.chars]
    if not any(show):
        show = [True, True, True]

    texts: list[tuple[str, str]] = []
    if not args.files:
        texts.append(("", sys.stdin.read()))
    for path in args.files:
        try:
            texts.append((str(path), path.read_text(encoding="utf-8")))
        except OSError as err:
            print(f"wc: {path}: {err.strerror}", file=sys.stderr)
            return 1

    results = [count(text) for _, text in texts]
    for (name, _), values in zip(texts, results, strict=True):
        print(fmt(values, show, name))
    if len(results) > 1:
        totals = tuple(sum(col) for col in zip(*results, strict=True))
        print(fmt(totals, show, "total"))

    if args.top:
        print(f"--- Top {args.top} ---")
        for word, n in top_words(" ".join(t for _, t in texts), args.top):
            print(f"{word:<16}{n:>4}")
    return 0
EOF
cat > src/wc/__main__.py <<'EOF'
from wc import main

raise SystemExit(main())
EOF
uv run wc lab/runbook.txt
uv run wc -lw lab/runbook.txt src/wc/__main__.py
printf 'a b\nc' | uv run wc

Erwartet:

       5      31     209 lab/runbook.txt
       5      31 lab/runbook.txt
       3       6 src/wc/__main__.py
       8      37 total
       1       3       5

Die wichtigsten Kniffe:

  • return a, b, c gibt ein Tupel zurück; for (name, _), values in zip(...) packt verschachtelt wieder aus. _ heißt „brauche ich nicht”.
  • zip(*results) transponiert die Liste von Zeilen in Spalten – die Summenzeile ist damit ein Einzeiler. strict=True meldet ungleich lange Eingaben, statt still abzuschneiden.
  • main(argv=None) gibt einen Exit-Code zurück. Das Konsolenskript ruft sys.exit(main()) auf, Tests rufen main([...]) direkt.
  • Fehlermeldungen gehen nach stderr (file=sys.stderr), Ergebnisse nach stdout.

Fortschritt speichern? Kostenlos registrieren

Drill 7: Tests, ruff und der Vergleich mit dem Original

Ab heute bekommt jedes Projekt eine kleine ruff-Konfiguration: Zeilenlänge (E501), typische Bugs (B), moderne Syntax (UP) und Vereinfachungen (SIM).

cat >> pyproject.toml <<'EOF'

[tool.ruff.lint]
extend-select = ["E501", "B", "UP", "SIM"]
EOF
mkdir -p tests
cat > tests/test_wc.py <<'EOF'
from wc import count, fmt, main, top_words


def test_count():
    assert count("a b\nc") == (1, 3, 5)
    assert count("") == (0, 0, 0)


def test_umlaute_sind_ein_zeichen():
    assert count("Prüfe\n") == (1, 1, 6)


def test_top_words_ignoriert_stoppwoerter():
    text = "Das Log. Das LOG! der Dienst"
    assert top_words(text, 2) == [("log", 2), ("dienst", 1)]


def test_fmt_nur_zeilen():
    assert fmt((5, 31, 209), [True, False, False], "x.txt") == "       5 x.txt"


def test_main_fehlende_datei(capsys):
    assert main(["gibt-es-nicht.txt"]) == 1
    assert "gibt-es-nicht.txt" in capsys.readouterr().err
EOF
uv run pytest -q
uv run ruff check && uv run ruff format --check

Erwartet:

.....                                                                    [100%]
5 passed in 0.01s
All checks passed!
4 files already formatted

capsys ist eine pytest-Fixture, die stdout/stderr einfängt (mehr an Tag 4). Jetzt der ehrliche Test – gleiche Ausgabe wie das Original:

for f in lab/runbook.txt pyproject.toml src/wc/__init__.py; do
  diff <(uv run wc "$f") <(/usr/bin/wc -lwm "$f") && echo "gleich: $f"
done
diff <(uv run wc -lw lab/*.txt pyproject.toml) \
     <(/usr/bin/wc -lw lab/*.txt pyproject.toml) && echo "gleich: mehrere"
diff <(cat src/wc/*.py | uv run wc) \
     <(cat src/wc/*.py | /usr/bin/wc -lwm) && echo "gleich: stdin"

Erwartet:

gleich: lab/runbook.txt
gleich: pyproject.toml
gleich: src/wc/__init__.py
gleich: mehrere
gleich: stdin

Warum <(...)? Process Substitution macht aus der Ausgabe eines Befehls eine Datei, die diff lesen kann. Kein diff-Output heißt: identisch.

Fortschritt speichern? Kostenlos registrieren

Drill 8: Das Tool ist fertig

uv run wc --top 3 lab/runbook.txt
uv run wc gibt-es-nicht.txt; echo "exit=$?"
uv run wc -x; echo "exit=$?"
uv run wc -h

Erwartet:

       5      31     209 lab/runbook.txt
--- Top 3 ---
zertifikat         3
prüfe              3
dienst             2
wc: gibt-es-nicht.txt: No such file or directory
exit=1
usage: wc [-h] [-l] [-w] [-m] [--top N] [files ...]
wc: error: unrecognized arguments: -x
exit=2
usage: wc [-h] [-l] [-w] [-m] [--top N] [files ...]

Zeilen/Wörter/Zeichen

positional arguments:
  files        Dateien (ohne: stdin)

options:
  -h, --help   show this help message and exit
  -l, --lines  Zeilen zählen
  -w, --words  Wörter zählen
  -m, --chars  Zeichen zählen
  --top N      Top-N-Wörter

Exit-Codes nach Unix-Konvention: 0 ok, 1 Laufzeitfehler, 2 falsche Bedienung (das erledigt argparse). Damit ist wc in Bash-Pipelines und CI verwendbar.

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

#!/usr/bin/env bash
check() { if eval "$2" >/dev/null 2>&1; then echo "✔ $1"; else echo "✘ $1"; fi; }
cd ~/py-lab/tag01-wc
check "wc zählt wie das Original" \
  "diff <(uv run wc lab/runbook.txt) <(/usr/bin/wc -lwm lab/runbook.txt)"
check "stdin funktioniert" "printf 'a b\nc' | uv run wc | grep -q '1       3       5'"
check "Top-Wort ist zertifikat" \
  "uv run wc --top 1 lab/runbook.txt | grep -q '^zertifikat'"
check "fehlende Datei gibt Exit 1" "! uv run wc gibt-es-nicht.txt"
check "Tests grün" "uv run pytest -q"
check "ruff sauber" "uv run ruff check && uv run ruff format --check"

Erwartet:

✔ wc zählt wie das Original
✔ stdin funktioniert
✔ Top-Wort ist zertifikat
✔ fehlende Datei gibt Exit 1
✔ Tests grün
✔ ruff sauber

Challenge

Ergänze --longest: Für jede Eingabe gibt wc zusätzlich die längste Zeile samt Länge aus.

Hinweis: max() nimmt wie sorted() ein key=-Argument, und default="" schützt vor leeren Dateien.

Lösung

In src/wc/__init__.py nach der --top-Option:

    parser.add_argument("--longest", action="store_true", help="längste Zeile")

und vor dem Block if args.top::

    if args.longest:
        for _, text in texts:
            line = max(text.splitlines(), key=len, default="")
            print(f"{len(line):>8} {line}")
uv run wc --longest -l lab/runbook.txt src/wc/__main__.py
uv run pytest -q && uv run ruff check

Erwartet:

       5 lab/runbook.txt
       3 src/wc/__main__.py
       8 total
      64 Erneuere das Zertifikat rechtzeitig, sonst fällt der Dienst aus.
      24 raise SystemExit(main())
5 passed in 0.01s
All checks passed!

Fortschritt speichern? Kostenlos registrieren

Enterprise-Notiz

  • read_text() lädt die ganze Datei in den Speicher. Für Logs im GB-Bereich zeilenweise iterieren (for line in f:) – mehr an Tag 14.
  • Encodings sind in gemischten Umgebungen nicht immer UTF-8; errors="replace" verhindert Abbrüche bei kaputten Bytes, verfälscht aber Zählungen.
  • Eigene Tools nie wie Systembefehle nennen, wenn sie global installiert werden; ein Präfix (pywc, acme-wc) vermeidet Verwechslungen im PATH.
  • Ausgabeformate, die andere Skripte parsen, sind eine Schnittstelle: stabil halten oder --json anbieten.