ich bin über ein komisches Verhalten gestolpert, was ich mir nicht so recht erklären kann.
Definiere ich einen Memoization-Dekorator, einmal als Klasse und einmal als Funktion, für eine rekursive Funktion, habe ich verschiedene maximale Rekursionstiefen bei der Ausführung. Mit der Standard Rekursionstiefe von 1000, bricht der Interpreter beim Klassendekorator bei 333 ab und beim Funktionsdekorator bei 500.
Es verwirrt mich ein Wenig, da die beiden Implementierungen an sich identisch sind.
Rein theoretisch müssten ja bei der Klasse mehr Rekursionsschritte ausgeführt werden, als bei der Funktion, damit so ein Verhalten ensteht. Aber warum führt die Klasse mehr Schritte aus? Vielleicht hat jemand hier eine Idee und kann mir helfen?
Code: Alles auswählen
class Memoize:
def __init__(self, func):
self.func = func
self.memo = {}
def __call__(self, x):
if x not in self.memo:
self.memo[x] = self.func(x)
return self.memo[x]
@Memoize
def fib(n):
if n == 0:
return 0
elif n == 1:
return 1
else:
return fib(n-1) + fib(n-2)
Code: Alles auswählen
def memoize(func):
memo = {}
def helper(x):
if x not in memo:
memo[x] = func(x)
return memo[x]
return helper
@memoize
def fib(n):
if n == 0:
return 0
elif n == 1:
return 1
else:
return fib(n-1) + fib(n-2)
