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,tuplesind die Arbeitspferde;collections.Counterzählt für dich.- Comprehensions (
[x for x in ...]) ersetzen die meisten Schleifen mitappend. - Am Ende vergleichst du dein Tool per
diffmit demwcvon 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.txtErwartet:
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/wcmit vollem Pfad: Innerhalb vonuv runliegt.venv/binvorne imPATH, dort wohnt bald dein eigeneswc.
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}")
EOFErwartet:
'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, waswcunter „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/:>8die Ausrichtung,:.2fdie 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"))
EOFErwartet:
<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))
EOFErwartet:
3 0
[('zertifikat', 3), ('prüfe', 3), ('das', 2)]
[('zertifikat', 3), ('prüfe', 3), ('das', 2)]
counts["vault"]würde mitKeyErrorabbrechen;get(key, 0)liefert den Default.items()gibt(key, value)-Tupel;sorted(..., key=...)sortiert nach dem zweiten Element.Countererledigt 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")))
EOFErwartet:
['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 wcErwartet:
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, cgibt 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=Truemeldet ungleich lange Eingaben, statt still abzuschneiden.main(argv=None)gibt einen Exit-Code zurück. Das Konsolenskript ruftsys.exit(main())auf, Tests rufenmain([...])direkt.- Fehlermeldungen gehen nach
stderr(file=sys.stderr), Ergebnisse nachstdout.
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 --checkErwartet:
..... [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 -hErwartet:
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 checkErwartet:
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 imPATH. - Ausgabeformate, die andere Skripte parsen, sind eine Schnittstelle:
stabil halten oder
--jsonanbieten.