python closures

Closure：如果在一个内部函数里，对在外部作用域（但不是在全局作用域）的变量进行引用，那么内部函数就被认为是闭包（closure）。它只不过是个"内层"的函数，由一个名字（变量）来指代，而这个名字（变量）对于“外层”包含它的函数而言，是本地变量。
demo:

#-*-coding:utf-8-*-

class Employee(object):

    def __init__(self,is_manager=False,salary=1000):
        self.is_manager = is_manager
        self.salary = salary

class Employees:
    def __init__(self,employees):
        self.employees = employees
    def do(self,block):
        for e in self.employees:
            block.value(e)
        
def anonymous_function(employee):
    if employee.is_manager:
        employee.salary = 2000

def total_cost_of_managers(employees):
    #TODO why not user total = 0 will raise Exception(UnboundLocalError: local variable 'total' referenced before assignment)?
    total = [0]
    def anonymous_function(employee):
        if employee.is_manager:
            total[0] = total[0]+employee.salary
    map(anonymous_function, employees)
    return total[0]

def total_cost_of_managers_2(employees):
    total = [0]
    class AnonymousClass:
        def value(self, employee):
            if employee.is_manager:total[0] = total[0]+employee.salary
    employees.do(AnonymousClass())
    return total[0]

def total_cost_of_managers_3(employees):
    class AnonymousClass:
        def __init__(self):
            self.total = 0
        def value(self, employee):
            if employee.is_manager:self.total = self.total+employee.salary
    block = AnonymousClass()
    employees.do(block)
    return block.total

def total_cost_of_managers_4(employees):
    class AnonymousClass:
        def __init__(self):
            self.total = 0
        def __call__(self, employee):
            if employee.is_manager:self.total = self.total+employee.salary
    block = AnonymousClass()
    map(block,employees)
    return block.total

def total_cost_of_managers_5(employees):
    total = 0
    for employee in employees:
        if employee.is_manager:total = total+employee.salary
    return total

employee = Employee()
employee.is_manager = True
employee2 = Employee()
employees = [employee,employee2]
#map(lambda e:e.is_manager and e.salary>1000 and e.salary+1000,employees)
map(anonymous_function,employees)
print 'total employee\'s salary is',employee.salary
print 'total manager\'s cost is',total_cost_of_managers(employees)
employees=Employees(employees)
print total_cost_of_managers_2(employees)
print total_cost_of_managers_3(employees)
print total_cost_of_managers_4([employee,employee2])
print total_cost_of_managers_5([employee,employee2])

详细例子可见 http://ivan.truemesh.com/archives/000411.html
Q:Decorators are an example of closures?
demo：

#-*-coding:utf-8-*-
import functors
def foo(f):
    @functools.wraps(f)
    def wraps(*args,**kwargs):
        print 'do something …'
        return f(*args,**kwargs)
    return wraps

@foo
class Bar:
    def __init__(self):
        self.name = 'foo is bar'

bar = Bar()
print bar.name

Q:what does functools.wraps do?
functools.partial is a useful utility function that copies attributes from the wrapped function to the wrapping function.

The functools.wraps function is a nice little convenience function that makes the wrapper function (i.e., the return value from the decorator) look like the function it is wrapping. This involves copying/updating a bunch of the double underscore attributes—specifically__module__, __name__, __doc__, and __dict__.

def update_wrapper(wrapper,
                   wrapped,
                   assigned = WRAPPER_ASSIGNMENTS,
                   updated = WRAPPER_UPDATES):
    """Update a wrapper function to look like the wrapped function


       wrapper is the function to be updated
       wrapped is the original function
       assigned is a tuple naming the attributes assigned directly
       from the wrapped function to the wrapper function (defaults to
       functools.WRAPPER_ASSIGNMENTS)
       updated is a tuple naming the attributes of the wrapper that
       are updated with the corresponding attribute from the wrapped
       function (defaults to functools.WRAPPER_UPDATES)
    """
    for attr in assigned:
        setattr(wrapper, attr, getattr(wrapped, attr))
    for attr in updated:
        getattr(wrapper, attr).update(getattr(wrapped, attr, {}))
    # Return the wrapper so this can be used as a decorator via partial()
    return wrapper


def wraps(wrapped,
          assigned = WRAPPER_ASSIGNMENTS,
          updated = WRAPPER_UPDATES):
    """Decorator factory to apply update_wrapper() to a wrapper function


       Returns a decorator that invokes update_wrapper() with the decorated
       function as the wrapper argument and the arguments to wraps() as the
       remaining arguments. Default arguments are as for update_wrapper().
       This is a convenience function to simplify applying partial() to
       update_wrapper().
    """
    return partial(update_wrapper, wrapped=wrapped,
                   assigned=assigned, updated=updated)

源码你会发现wraps调用的是一个对partial(update_wrapper, ...)的简单包装。
partial主要是用来修改函数签名，使一些参数固化，以提供一个更简单的函数供以后调用 update_wrapper是wraps的主要功能提供者，它负责考贝原函数的属性，默认是：'__module__', '__name__', '__doc__'， '__dict__'。
有关functools可以参考我之前的整理：
http://2057.iteye.com/blog/1798472
详细的介绍closures以及问题可参考：
http://blog.csdn.net/marty_fu/article/details/7679297
参考资料：
http://ivan.truemesh.com/archives/000392.html
http://ivan.truemesh.com/archives/000411.html
http://ivan.truemesh.com/archives/000425.html
http://feilong.me/2012/06/interesting-python-closures
http://en.wikipedia.org/wiki/Python_syntax_and_semantics
http://blaag.haard.se/Python-Closures-and-Decorators--Pt--1/
http://blaag.haard.se/Python-Closures-and-Decorators--Pt--2/
http://www.ibm.com/developerworks/cn/linux/l-cn-closure/index.html
http://stackoverflow.com/questions/233673/lexical-closures-in-python
http://stackoverflow.com/questions/308999/what-does-functools-wraps-do
http://stackoverflow.com/questions/2796855/python-closures-example-code
http://blogs.oucs.ox.ac.uk/inapickle/2012/01/05/python-decorators-with-optional-arguments/