évaluation paresseuse et liaison tardive de python?

Question

quand est l'évaluation paresseuse? (générateur, si, itérateur?), quand est-ce que la liaison est tardive? (fermeture, fonctions régulières?)

a = [1,2,3,4] 
    b = [lambda y: x for x in a] 
    c = (lambda y: x for x in a) #lazy evaluation 
    d = map(lambda m: lambda y:m, a) #closure 
    for i in b: 
     print i(None) 
    # 4 4 4 4 
    for i in c: 
     print i(None) 
    # 1 2 3 4 
    for i in d: 
     print i(None) 
    # 1 2 3 4 

Answer 1

Cela ressemble à des devoirs, donc je ne vais pas seulement vous donner les réponses. Voici deux fonctions que vous pouvez parcourir et voir comment les valeurs changent.

def make_constants_like_generator(): 
    def make_constant(x): 
     def inner(y): 
      return x 
     return inner 
    results = [] 
    for i in [1, 2, 3, 4]: 
     results.append(make_constant(i)) 
     for f in results: 
      print f(None) 
    return results 

def make_constants_like_list(): 
    x = None 
    results = [] 
    for i in [1, 2, 3, 4]: 
     x = i 
     def inner(y) 
      return x 
     results.append(inner) 
     for f in results: 
      print f(None) 
    return results 

L'évaluation paresseuse attend jusqu'au dernier moment possible pour évaluer une expression. Le contraire est une évaluation avide. L'expression du générateur est paresseuse, elle ne fait rien tant qu'elle n'est pas itérée. L'expression de la liste est impatiente, dès qu'elle est rencontrée, la liste est remplie de valeurs.

La liaison anticipée et la liaison tardive concernent la façon dont le système détermine le nom d'un nom. Tous les noms en python sont en retard. Combiné avec l'évaluation paresseuse qui signifie que ce nom est lié à peut changer avant que les expressions qui l'utilisent sont évaluées

def map(func, iter): 
    return (func(val) for val in iter)