I have to write a function which gets three arguments. lower, higher an cache. Lower and higher gives a range where a new list is created with. This part is this code:
def one_range(lower, higher, cache): list1 = [] for i in range(lower,higher): list1.append(i) return list1 If "range" is called twice with the same arguments, both times the same list should be returned. The second time the list is not generated again, but reused. How can i do that?
Edited the orinal function
Assuming that cache is a dictionary, you can make a tuple from the other parameters and see whether that tuple is in the dict. If it is, return the value from the dict, otherwise calculate the value and store it in the dict before returning it. You might also provide a default value for cache so the function can also be used without it.
def one_range(lower, higher, cache=None): if cache is not None and (lower, higher) in cache: return cache[(lower, higher)] lst = [] for i in range(lower,higher): lst.append(i) if cache is not None: cache[(lower, higher)] = lst return lst Example:
c = {} x = one_range(2, 4, c) y = one_range(1, 4, c) z = one_range(2, 4, c) print(x is z) # True print(c) # {(2, 4): [2, 3], (1, 4): [1, 2, 3]} That's a lot of boiler plate code, though, cluttering the function. In practice, this can be done much easier with a function decorator. If you can not use functools.lru_cache, you can implement your own memoization decorator in just a few lines of code:
def memo(f): f.cache = {} def _f(*args, **kwargs): if args not in f.cache: f.cache[args] = f(*args, **kwargs) return f.cache[args] return _f Then use it on your function, without the no longer needed cache parameter:
@memo def one_range(lower, higher): lst = [] for i in range(lower,higher): lst.append(i) return lst 
return list(cache[(lower, higher)]); using a generic @memo decorator it would be a bit more involved.def one_range(lower, higher, cache=dict()): to use a mutable default argument as storage. For once it would be a good use of that "feature". The drawback is that the cache cannot be cleared that wayAssuming that your arguments are hashable, you can do this with functools.lru_cache() (Python 3.2+):
import functools @functools.lru_cache(maxsize=128) def mrange(lower, higher): print('mrange was called') res = [] for i in range(lower, higher): res.append(i) return res Smaller points:
range and list.mrange.cache_clear() to clear the cache.Example:
>>> mrange(1, 10) mrange was called [1, 2, 3, 4, 5, 6, 7, 8, 9] >>> mrange(1, 10) [1, 2, 3, 4, 5, 6, 7, 8, 9] 
range. You won't be able to call the originalrangefrom inside it...listtoo...