Créer des valeurs par défaut pour le dictionnaire en python

Nous allons avoir une méthode qui permettrait de mettre en cache les résultats qu'il calcule.

"Si" approche:

def calculate1(input_values):
    if input_values not in calculate1.cache.keys():
        # do some calculation
        result = input_values
        calculate1.cache[input_values] = result
    return calculate1.cache[input_values]
calculate1.cache = {}

"Sauf" approche:

def calculate2(input_values):
    try:
       return calculate2.cache[input_values]
    except AttributeError:
       calculate2.cache = {}
    except KeyError:
       pass
    # do some calculation
    result = input_values
    calculate2.cache[input_values] = result
    return result

"get/a" approche:

def calculate3(input_values):

    if not hasattr(calculate3, cache):
        calculate3.cache = {}

    result = calculate3.cache.get(input_values)
    if not result:
        # do some calculation
        result = input_values
        calculate3.cache[input_values] = result
    return result

Est-il une autre (plus rapide)? Celui qui est le plus pythonic? Laquelle aimeriez-vous utiliser?

Note: Il y a une différence de vitesse:

calculate = calculateX # depening on test run
for i in xrange(10000):
    calculate(datetime.utcnow())

Résultats time python test.py:

calculate1: 0m9.579s
calculate2: 0m0.130s
calculate3: 0m0.095s

source d'informationauteur Martin Tóth

  1. 23

    Utiliser un les collections.defaultdict. Il est conçu justement à cet effet.

  2. 5

    Bien sûr; c'est Python, après tout: il suffit d'utiliser un defaultdict.

  3. 2

    Eh bien, si vous essayez de memoize quelque chose, de son mieux pour utiliser un Memoize classe et les décorateurs.

    class Memoize(object):
    def __init__(self, func):
        self.func = func
        self.cache = {}

    def __call__(self, *args):
        if args not in self.cache:
            self.cache[args] = self.func(*args)
        return self.cache[args]

    Maintenant définir une fonction pour être memoized, dire d'un renforcement de la fonction qui fait dire 100 000 les sommes md5 d'une chaîne de hachages:

    import md5

def one_md5(init_str):
    return md5.md5(init_str).hexdigest()

@Memoize
def repeat_md5(cur_str, num=1000000, salt='aeb4f89a2'):
    for i in xrange(num):
        cur_str = one_md5(cur_str+salt)
    return cur_str

    L' @Memoize fonction de décorateur est équivalente à la définition de la fonction, puis de définir repeat_md5 = Memoize(repeat_md5). La première fois que vous l'appelez pour un ensemble particulier d'arguments, la fonction prend environ une seconde de calcul; et la prochaine fois que vous appeler de son quasi instantanée à la lecture de son cache.

    Comme pour la méthode de memoization; tant que vous ne faites pas quelque chose de stupide (comme la première méthode où vous ne "si la clé dans some_dict.les touches()" plutôt que "si la clé dans some_dict"), il ne devrait pas être beaucoup d'une différence significative. (La première méthode est mauvaise car vous générer un tableau à partir du dictionnaire, d'abord, et ensuite de vérifier pour voir si la clé est en elle; plutôt que de juste vérifier pour voir si la clé est dans le dict (Voir Codage comme un pythonista)). Aussi attraper les exceptions seront plus lent que si les déclarations de la nature (vous devrez créer une exception alors l'exception de gestionnaire a le gérer; et puis, vous l'attraper).