Add functools into relevant lessons

Author: huangsam

ultimatepython/advanced/benchmark.py

@@ -3,39 +3,49 @@
 features are added and extra layers of complexity to the main features.
 Benchmarking is an approach that helps developers use profiling metrics
 and their code intuition to optimize programs further. This module uses
-cProfile to compare the performance of two functions with each other.
+cProfile to compare the performance of two functions with each other,
+showcasing the impact of caching/memoization with `functools.cache`.
 """
 
 import cProfile
 import io
 import pstats
-import time
+from functools import cache
 
-# Module-level constants
-_SLEEP_DURATION = 0.001
 
+def fib_naive(n: int) -> int:
+    """Calculate Fibonacci number recursively without caching.
 
-def finish_slower() -> None:
-    """Finish slower by sleeping more."""
-    for _ in range(20):
-        time.sleep(_SLEEP_DURATION)
+    This has O(2^N) time complexity due to redundant calculations.
+    """
+    if n < 2:
+        return n
+    return fib_naive(n - 1) + fib_naive(n - 2)
 
 
-def finish_faster() -> None:
-    """Finish faster by sleeping less."""
-    for _ in range(10):
-        time.sleep(_SLEEP_DURATION)
+@cache
+def fib_cached(n: int) -> int:
+    """Calculate Fibonacci number recursively with caching.
+
+    This has O(N) time complexity as each value is computed only once.
+    """
+    if n < 2:
+        return n
+    return fib_cached(n - 1) + fib_cached(n - 2)
 
 
 def main() -> None:
     # Create a profile instance
     profile = cProfile.Profile()
 
+    # Clear the cache before benchmarking to ensure clean metrics
+    fib_cached.cache_clear()
+
     profile.enable()
 
-    for _ in range(2):
-        finish_slower()
-        finish_faster()
+    # Compare naive vs cached Fibonacci calculations for N=15
+    fib_naive(15)
+    fib_cached(15)
 
     profile.disable()
 
@@ -46,17 +56,17 @@ def main() -> None:
     buffer = io.StringIO()
     ps = pstats.Stats(profile, stream=buffer).sort_stats("cumulative")
 
-    # Notice how many times each function was called. In this case, the main
-    # bottleneck for `finish_slower` and `finish_faster` is `time.sleep`
-    # which occurred 60 times. By reading the code and the statistics, we
-    # can infer that 40 occurrences came from `finish_slower` and 20 came
-    # from `finish_faster`. It is clear why the latter function runs faster
-    # in this case, but identifying insights like this are not simple in
-    # large projects. Consider profiling in isolation when analyzing complex
-    # classes and functions
+    # print_stats writes the tabular profiling info to the buffer
     ps.print_stats()
-    time_sleep_called = any("60" in line and "time.sleep" in line for line in buffer.getvalue().split("\n"))
-    assert time_sleep_called is True
+    output = buffer.getvalue()
+
+    # Naive recursive fib(15) requires exactly 1,973 calls.
+    # Cached recursive fib(15) requires exactly 16 calls (inputs 0 to 15).
+    naive_called = any("1973" in line and "fib_naive" in line for line in output.split("\n"))
+    cached_called = any("16" in line and "fib_cached" in line for line in output.split("\n"))
+
+    assert naive_called is True
+    assert cached_called is True
 
 
 if __name__ == "__main__":

ultimatepython/syntax/function.py

@@ -9,6 +9,7 @@
 """
 
 from collections.abc import Callable
+from functools import partial
 from typing import Any
 
 
@@ -55,6 +56,11 @@ def main() -> None:
     add_result_int = add(1, 2)
     assert add_result_int == 3
 
+    # We can use `functools.partial` to create a new function with some
+    # arguments pre-filled, which is a cleaner alternative to lambdas in many cases.
+    add_five = partial(add, 5)
+    assert add_five(10) == 15
+
     # The `add` function can be used for strings as well
     add_result_string = add("hello", " world")
     assert add_result_string == "hello world"