small changes for timing

.gitignore

 _build
 .ipynb
+*checkpoint.md
+*cpython*
\ No newline at end of file

src/Dekoratoren/dekoratoren_exercise.md

@@ -4,8 +4,10 @@ jupytext:
   text_representation:
     extension: .md
     format_name: myst
+    format_version: 0.13
+    jupytext_version: 1.10.3
 kernelspec:
-  display_name: Python 3
+  display_name: Python 3 (ipykernel)
   language: python
   name: python3
 ---
@@ -16,13 +18,15 @@ kernelspec:
 
 Schreiben Sie mithilfe des Moduls `time` einen Dekorator, der bei Funktionsaufruf ausgibt, wie lange das Ausführen einer Funktion dauert. Lesen Sie sich dazu die Modulbeschreibung von `time` durch.
 
-```{code-cell}
-:tags: ['hide-cell']
+```{code-cell} ipython3
+:tags: [hide-cell]
+
 import time # Verwende z.B.: clock() oder perf_counter()
 ```
 
-```{code-cell}
-:tags: ['hide-cell']
+```{code-cell} ipython3
+:tags: [hide-cell]
+
 def timethis(func):
     def new_func(*args):
         before = time.perf_counter()
@@ -34,19 +38,20 @@ def timethis(func):
     return new_func
 ```
 
-```{code-cell}
-:tags: ['hide-cell']
+```{code-cell} ipython3
+:tags: [hide-cell]
+
 @timethis
 def add(a,b):
     return a+b
 ```
 
-```{code-cell}
-:tags: ['hide-cell']
+```{code-cell} ipython3
+:tags: [hide-cell]
+
 add(2,6)
 ```
 
-
 ## Aufgabe 2
 
 Schreiben Sie eine Funktion, die die Primfaktoren einer Zahl zählt (mit Vielfachheit, d.h. 8 hat 3 Primfaktoren). Dabei kann man wie folgt vorgehen:
@@ -57,10 +62,11 @@ Schreiben Sie eine Funktion, die die Primfaktoren einer Zahl zählt (mit Vielfac
 
 Bestimmen Sie dann als Test die Anzahl der Primfaktoren für n = 100000.
 
-Verwenden Sie `%timeit`, um die Berechnungsdauer des Funktionsaufrufes zu bestimmen. Wie können Sie diese Berechnung auf einfache Weise beschleunigen?
+Verwenden Sie `%timeit -n1 -r2` in der Zeile vor dem Aufruf um die Berechnungsdauer des Funktionsaufrufes zu bestimmen. Wie können Sie dafür sorgen das nachfolgende Berechnungen schneller laufen?
+
+```{code-cell} ipython3
+:tags: [hide-cell]
 
-```{code-cell}
-:tags: ['hide-cell']
 def count_prime_factors(n):
     for k in range(2, int(n**0.5)+1):
         if n%k == 0:
@@ -68,13 +74,15 @@ def count_prime_factors(n):
     return 1
 ```
 
-```{code-cell}
-:tags: ['hide-cell']
-%timeit count_prime_factors(100000)
+```{code-cell} ipython3
+:tags: [hide-cell]
+
+%timeit -n1 -r2 count_prime_factors(1000000)
 ```
 
-```{code-cell}
-:tags: ['hide-cell']
+```{code-cell} ipython3
+:tags: [hide-cell]
+
 from functools import lru_cache
 
 @lru_cache(maxsize=None)
@@ -85,9 +93,10 @@ def count_prime_factors_cached(n):
     return 1
 ```
 
-```{code-cell}
-:tags: ['hide-cell']
-%timeit count_prime_factors_cached(100000)
+```{code-cell} ipython3
+:tags: [hide-cell]
+
+%timeit -n1 -r2 count_prime_factors_cached(1000000)
 ```
 
 ## Aufgabe 3\*
@@ -108,8 +117,9 @@ b) Schreiben Sie einen Dekorator, der die Rekursions-Tiefe zählt und bei jedem
 
 *Hinweis*: Jede Funktion, die dekoriert wird, braucht einen eigenen Rekursions-Zähler. Eine Möglichkeit ist das Erzeugen einer solchen Variable im Scope des Decorators, so dass bei jedem Verwenden des Decorators ein neuer Zähler erzeugt wird.
 
-```{code-cell}
-:tags: ['hide-cell']
+```{code-cell} ipython3
+:tags: [hide-cell]
+
 def potenz(x,n):
     if n == 1:
         return x
@@ -120,8 +130,9 @@ def potenz(x,n):
 potenz(5,2)
 ```
 
-```{code-cell}
-:tags: ['hide-cell']
+```{code-cell} ipython3
+:tags: [hide-cell]
+
 from functools import wraps
 
 def printdepth(func):
@@ -138,8 +149,9 @@ def printdepth(func):
     return new_func
 ```
 
-```{code-cell}
-:tags: ['hide-cell']
+```{code-cell} ipython3
+:tags: [hide-cell]
+
 @printdepth
 def potenz(x,n):
     if n == 1:
@@ -159,8 +171,9 @@ Speichern Sie dieses in Form eines Dictionaries, das bei jedem Funktionsaufruf a
 
 *Hinweis*: Hier ist der Vorlesungsabschnitt zum Thema *Scope* hilfreich.
 
-```{code-cell}
-:tags: ['hide-cell']
+```{code-cell} ipython3
+:tags: [hide-cell]
+
 def cacheit(func):
     cache = {}
     def new_func(*args):
@@ -175,19 +188,22 @@ def cacheit(func):
     return new_func
 ```
 
-```{code-cell}
-:tags: ['hide-cell']
+```{code-cell} ipython3
+:tags: [hide-cell]
+
 @cacheit
 def add(a,b):
     return a+b
 ```
 
-```{code-cell}
-:tags: ['hide-cell']
+```{code-cell} ipython3
+:tags: [hide-cell]
+
 add(2,1)
 ```
 
-```{code-cell}
-:tags: ['hide-cell']
+```{code-cell} ipython3
+:tags: [hide-cell]
+
 add(2,3)
 ```