memoization

I'm writing a class in python and I have an attribute that will take a relatively long time to compute, so I only want to do it once . Also, it will not be needed by every instance of the class, so I don't want to do it by default in __init__ . I'm new to Python, but not to programming. I can come up with a way to do this pretty easily, but I've found over and over again that the 'Pythonic' way of doing something is often much simpler than what I come up with using my experience in other languages. Is there a 'right' way to do this in Python? Maxime R. Python ≥ 3.2 You should use both

The following code is from Pathikrit's Dynamic Programming repository. I'm mystified by both its beauty and peculiarity. def subsetSum(s: List[Int], t: Int) = { type DP = Memo[(List[Int], Int), (Int, Int), Seq[Seq[Int]]] implicit def encode(key: (List[Int], Int)) = (key._1.length, key._2) lazy val f: DP = Memo { case (Nil, 0) => Seq(Nil) case (Nil, _) => Nil case (a :: as, x) => (f(as, x - a) map {_ :+ a}) ++ f(as, x) } f(s, t) } The type Memo is implemented in another file: case class Memo[I <% K, K, O](f: I => O) extends (I => O) { import collection.mutable.{Map => Dict} val cache = Dict

I want to convert my coin change function to memoized function to do that, I decided to use dictionary so that a key in my dict will be the coin and the value will be a list that contain all the coins that can change the "key" coin. what I did is: def change(a,kinds=(50,20,10,5,1)): if(a==0): return 1 if(a<0 or len(kinds)==0): return 0 return change(a-kinds[0],kinds)+change(a,kinds[1:]) def memoizeChange(f): cache={} def memo(a,kinds=(50,20,10,5,1)): if len(cache)>0 and kinds in cache[a]: return 1 else: if(f(a,kinds)==1): cache[a]=kinds // or maybe cache[a].append(..) return cache[a]+memo(a

How can I memoize a promise-based function? Would straightforward memoization of the function suffice? function foo() { return new Promise((resolve, reject) => { doSomethingAsync({ success: resolve, fail: reject }); }); }; Would this suffice? var fooMemoized = memoize(foo); Note: this question has been updated to remove the deferred anti-pattern. Bergi Yes, that will suffice. Promises are simple return values, which is their great benefit - in contrast to callbacks, where memoisation code would be horrible. You only might want to make sure that the memoized promise is uncancellable, if your

I've been using the following memoizing decorator (from the great book Python Algorithms: Mastering Basic Algorithms in the Python Language ... love it, btw). def memo(func): cache = {} @ wraps(func) def wrap(*args): if args not in cache: cache[args] = func(*args) return cache[args] return wrap The problem with this decorator is that the dictionary-based cache means that all of my arguments must be hashable. Does anyone have an implementation (or a tweak to this one) that allows for unhashable arguments (e.g. dictionaries)? I know that the lack of a hash value means that the question of "is

Is it possible to combine memoization and tail-recursion somehow? I'm learning F# at the moment and understand both concepts but can't seem to combine them. Suppose I have the following memoize function (from Real-World Functional Programming ): let memoize f = let cache = new Dictionary<_, _>() (fun x -> match cache.TryGetValue(x) with | true, y -> y | _ -> let v = f(x) cache.Add(x, v) v) and the following factorial function: let rec factorial(x) = if (x = 0) then 1 else x * factorial(x - 1) Memoizing factorial isn't too difficult and making it tail-recursive isn't either: let rec