[python] 这次答应我，一举拿下闭包从此涨薪不是梦！

• 因为闭包只有在被调用时才执行操作，所以它可以被用来定义控制结构。例如：在Smalltalk语言中，所有的控制结构，包括分歧条件(if/then/else)和循环(while和for)，都是通过闭包实现的。用户也可以使用闭包定义自己的控制结构。
  
• 多个函数可以使用一个相同的环境，这使得它们可以通过改变那个环境相互交流。
  
• 闭包可以用来实现对象系统。
  

++
void foo(string myname) {
    typedef vector<string> names;
    int y;
    names n;
    // ...
    names::iterator i =
     find_if(n.begin(), n.end(), [&](const string& s){return s != myname && s.size() > y;});
    // 'i' is now either 'n.end()' or points to the first string in 'n'
    // 'i' 现在是'n.end()'或指向'n'中第一个
    // 不等于'myname'且长度大于'y'的字符串
}

def get_name():
  name = "haishiniu"
print(name)

• Local 很好理解，即作用于同一作用域的局部名称
  
• Enclosing 即 Enclosing Scope，闭包中的核心，后续会详细解释
  
• Global 全局名称
  
• Builtins 内建，比如一些内建的函数: str()、int()...
  

def get_scope():
  name = "haishiniu"
  def get_name():
    print(name)
# Output: "haishiniu"
get_scope()
# NameError: name 'name' is not defined
print(name)

def get_scope():
  name = "haishiniu"
  def get_name():
    print(name)
  return get_name
test = get_scope()
test()  # Output: "haishiniu"

def get_num_scope():
  num = 1
  def get_num ():
    num = 2
    print(num)
  print(num)
  get_num()
  print(num)
  return get_num
test = get_num_scope()
test()

def get_list_data_scope():
  list_data = [1]
  def get_list_data():
    list_data.append(2)
    print(list_data)
  print(list_data)
  get_list_data()
  print(list_data)
  return get_list_data
test = get_list_data_scope()
test()

func_list = []
for i in range(3):
  def multi_f():
    return i * 2
  func_list.append(multi_f)
for f in func_list:
  print(f())

for i in range(100):
  out_put = i + 1
print(out_put)

func_list = []
for i in range(3):
  def get_data_scope(x):
    def get_data():
      return x * 2
    return get_data
  func_list.append(get_data_scope(i))
for f in func_list:
  print(f())

• 使用装饰器 @server.add_middleware 添加自定义中间件
  
• 用装饰器 @server.add_func('core_func_name') 添加自定义核心件
  

# 在会话中保存上下文
class Context():
  def __init__(self):
    self._next = []
  @property
  def next(self):
    return self._next

class Server():
  def __init__(self):
    self._middlewares = []   # 中间件队列
    self._funcs = {}  # 自定义核心件映射容器
  def add_middleware(self, middleware_func):
    """
    添加中间件
    """
    self._middlewares.append(middleware_func)
    return middleware_func
  def add_func(self, name):
    """
    注册自定义核心件
    """
    def decorate(func):
      self._funcs.setdefault(name, func)
      return func
    return decorate
  def _load_middleware(self, ctx, func):
    """
    加载中间件
    """
    def next(*args, **kwargs):
      return func(ctx, *args, **kwargs)
    for middleware in reversed(self._middlewares):
      # 使用闭包来封装中间件
      def f(middleware=middleware, next=next):
        def new_next(*args, **kwargs):
          ctx._next = next
          return middleware(ctx, *args, **kwargs)
        return new_next
      next = f()
    return next
  def _wrap(self, func):
    def f(*args, **kwargs):
      ctx = Context()
      return self._load_middleware(ctx, func)(*args, **kwargs)
    return f
  def initilize(self):
    """
    初始化服务
    """
    for name, func in self._funcs.items():
      self.__setattr__(name, self._wrap(func))
@server.add_middleware
def the_first_middleware(ctx, *args, **kwargs):
  print("The first middleware ")
  return ctx.next(*args, **kwargs)

@server.add_middleware
def the_second_middleware(ctx, *args, **kwargs):
  print("The second middleware")
  return ctx.next(*args, **kwargs)

@server.add_middleware
def the_last_middleware(ctx, *args, **kwargs):
  print("The last middleware")
  return ctx.next(*args, **kwargs)

@server.add_func('core_func')
def core_func(ctx, *args, **kwargs):
  return "The core function "
server = Server()
server.initilize()
print(server.core_func())