Profiling mit cProfile

import cProfile
import pstats
from collections.abc import Callable


def profile_calls(func: Callable[..., object], *args: object) -> dict[str, int]:
    # Run func(*args) under cProfile.Profile, then return {function name: number of calls}.
    # A recursive function's ncalls looks like "15/1": count the first number.
    func(*args)
    return {}

from main import profile_calls


def fib(n):
    return n if n < 2 else fib(n - 1) + fib(n - 2)


def helper(x):
    return x * 2


def three_helpers():
    return helper(1) + helper(2) + helper(3)


def test_counts_calls():
    """three_helpers läuft einmal und ruft helper 3-mal auf"""
    calls = profile_calls(three_helpers)
    got = calls.get("three_helpers"), calls.get("helper")
    assert got == (1, 3), f"Ergebnis {got!r} für three_helpers und helper, erwartet (1, 3)"


def test_recursion():
    """fib(6) macht insgesamt 25 Aufrufe, gezählt aus ncalls 25/1"""
    calls = profile_calls(fib, 6)
    assert calls.get("fib") == 25, f"calls['fib'] ist {calls.get('fib')!r}, erwartet 25: Nehmen Sie die Zahl vor dem Schrägstrich"


def test_values_are_ints():
    """Jede Zahl ist ein int"""
    calls = profile_calls(three_helpers)
    bad = {name: n for name, n in calls.items() if not isinstance(n, int)}
    assert calls and not bad, f"diese Zahlen sind keine ints: {bad!r}" if bad else "das dict ist leer"

def normalise(word: str) -> str:
    return word.strip().lower()


def count_known(words: list[str], vocabulary: list[str]) -> int:
    count = 0
    for word in words:
        if normalise(word) in [normalise(v) for v in vocabulary]:
            count += 1
    return count


if __name__ == "__main__":
    import cProfile

    words = ["Apple", "pear ", "kiwi", "PLUM"] * 500
    vocabulary = [f"fruit{i}" for i in range(300)] + ["apple", "pear", "plum"]
    cProfile.run("print(count_known(words, vocabulary))", sort="ncalls")

import cProfile
import pstats

from main import count_known

WORDS = ["Apple", "pear ", "kiwi", "PLUM"] * 50
VOCABULARY = [f"fruit{i}" for i in range(30)] + ["apple", " Pear", "plum"]


def normalise_calls(words, vocabulary):
    with cProfile.Profile() as profiler:
        result = count_known(words, vocabulary)
    rows = pstats.Stats(profiler).get_stats_profile().func_profiles
    return result, int(rows["normalise"].ncalls) if "normalise" in rows else 0


def test_same_answer():
    """150 der 200 Wörter sind bekannt"""
    got = count_known(WORDS, VOCABULARY)
    assert got == 150, f"count_known lieferte {got!r}, erwartet 150"


def test_normalises_each_word_once():
    """normalise läuft einmal pro Wort und einmal pro Vokabular-Eintrag"""
    result, calls = normalise_calls(WORDS, VOCABULARY)
    expected = len(WORDS) + len(VOCABULARY)
    assert calls == expected, f"normalise wurde {calls}-mal aufgerufen, erwartet {expected}: Normalisieren Sie das Vokabular einmal, vor der Schleife"


def test_empty_words():
    """Keine Wörter: das Ergebnis ist 0"""
    got = count_known([], VOCABULARY)
    assert got == 0, f"count_known([], ...) lieferte {got!r}, erwartet 0"