如何将计算结果存储在 Python 中，这样我的程序就不会对同一事物进行两次计算？

Question

I keep having problems with programs in Python (I'm a complete newb) where it doesn't store the data from a computation and does it over and over again when I feel like it should have saved it. How can I make Python save the answer so it doesn't compute the program over and over?

ex:

import prime
def g(x):
    i=0
    while i<len(prime.sieve(x)):
        print str(prime.sieve(x)[i])+' is prime'
        i=i+1

Here's the "prime" module in case someone wants to compile this:

def sieve(max):
    #Takes in a number, and returns all primes between 2 and that number

    #Start with all of the numbers
    primes = range(2,max+1)
    #Start running through each number 
    for i in primes:
            #Start with double the number, and
            j = 2
            #remove all multiples
            while i * j <= primes[-1]:
                    #As long as the current multiple of the number
                    #is less than than the last element in the list
                    #If the multiple is in the list, take it out
                    if i * j in primes:
                            primes.remove(i*j)
                    j=j+1
    return primes

Anyway, the first bit of code computes the list "prime.sieve(x)" over and over, and I want to save it for reference when printing.

Thanks!

rofls

Answer 1

saved_sieve_map = {}
def saved_sieve(x):
  if x not in saved_sieve_map:
    saved_sieve_map[x] = sieve(x)
  return saved_sieve_map[x]

Answer 2

This is called memoization. Fortunately, there are lots of memoization decorators, and one of them is here: http://wiki.python.org/moin/PythonDecoratorLibrary#Memoize

The example usage is:

@memoized
def fibonacci(n):
   "Return the nth fibonacci number."
   if n in (0, 1):
      return n
   return fibonacci(n-1) + fibonacci(n-2)

print fibonacci(12)

(The @memoized expression applies the decorator to the function following it).

Answer 3

You might just assign it to a local variable:

i=0
saveit = prime.sieve(x)
while i<len(saveit):
    print str(saveit[i])+' is prime'
    i=i+1

Note: it does still calculate the sieve even if g(x) is called twice with the same value of x . For a version which does save the calculation even beyond the scope of g see eg Keith's answer.

Answer 4

This function can be used to remove recursive complexity.

from functools import wraps
def memo(func): 
    cache = {}
    @wraps(func)
    def wrap(*args):
        if args not in cache: 
            cache[args] = func(*args)
        return cache[args] 
    return wrap

Anyhow this is my implementation of the sieve which should run way faster than yours.

@memo
def sieve(end):
    import itertools
    lng = ((end/2)-1+end%2)
    sieve = [True]*(lng+1)
    for i in itertools.ifilter(lambda z: sieve[z],xrange(int(end**0.5) >> 1)):
        n=len(sieve[int((i*(i + 3) << 1) + 3): int(lng): int((i << 1) + 3)])
        sieve[int((i*(i + 3) << 1) + 3): int(lng): int((i << 1) + 3)]=[False]*n
    return sum([(x << 1) + 3 for x in itertools.compress(xrange(lng),sieve)])+2