python中的闭包从表现形式上定义（解释）为：如果在一个内部函数里，对在外部作用域（但不是在全局作用域）的变量进行引用，那么内部函数就被认为是闭包(closure)。
以下说明主要针对 python2.7，其他版本可能存在差异。
也许直接看定义并不太能明白，下面我们先来看一下什么叫做内部函数：
def wai_hanshu(canshu_1):
def nei_hanshu(canshu_2): # 我在函数内部有定义了一个函数
return canshu_1*canshu_2
return nei_hanshu # 我将内部函数返回出去
a = wai_hanshu(123) # 此时 canshu_1 = 123
print a
print a(321) # canshu_2 = 321
aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAXQAAAAnCAIAAACQbCTpAAADw0lEQVR4nO2c3ZXbIBBG1VXoJBWYPlJAqMY0syrFD8qDhPiZQci7wrGle88+6LB4YBB8DGAzTAAAHRj+dwUA4JwgLgDQBcQFALqAuABAFxAXAOjCd8VldGYYhmGw/tDqTN4ebvKbZXl7jH9H2QH4MPaLi7dxgIzOzMPlcC0Y3c2NRxr8SVlHefdKxQyqbzZcE3lCQlDBWRAXZK7UmbRbCDt50mJIqWFmBM7CTnEphsdho2V07o171TuKy3aLjc4sJXlbkxeRJxFZb4MshDqn88hiMfxrkaDVNd2OW9K89xs1fKX+wovYIy6xPwTebtQ9jDnf3/MtNjpj4vjW1aXM85XZXJ8TcTHuK/tUrT6157lUF7SlVsO6HMJn0haX4p0nYe4ya3mbPdzDLoNzJgt+i6g6C73VmTD91GymYnmakqG4XXpIUMuSrgs7uRN6WdGzZKpP8xQtptbhYUy5DJEtplU4Hd7hXRg3LlW9NyTAFA0kXcjL1sVOSFGMXzZKV2Yx+GSa4qL2ntoqKX2Yu+Waom7TSONFSuilsbdKy9OUiUut9DCuY69vxk3Szh5PVaeadkoexmh5mpvQMuc8ZNc1S9VarghF5LK6UORT6qMEOau2PPf24bPZsyxqdoLtsbcxig6xPE2KuCgSIOb8PeIiyoqWNuqzxgvPeZHyMEaU1axzbdER90tqedIcss73LKjYEghhZ05M9mU2lkUoy7k4ZEM33eGrDZ41ckm3JNcP+kpnVSOXb4hL0qfH8ZnIpeJO9EbJI5YA9YfYYiUxcollqS2WoW2Xhsgl/EfmSZUjvJ0schlT1ahHLpqdeh42dM/O80fR8mxxTbPWDsNw+2PX6Tbd2ihW8aktEV5knbHccxGWlT0Xkae+41Pp1BU7S1Byu5lh+HX7LfLcy/NY3U7WYloNYuQyl1Wc41ZHYnHQ6+3y7JOv22h5VsIiSLTP6le5LVO+4PI1ywmj7AccRZ+Sk3xDt3K28sGczyO4GojLTD7rbsYGrwFxgU8HcXlTzucRXI3ziMv5/v53owL8iJOICwC8G4gLAHQBcQGALiAuANAFxAUAuoC4AEAXEBcA6EJbXNTLDbMfjCiXGwLA1WmJixeXG4bk+Cs45XJDALg6DXHRLzf0drD2+auMAOBCNMRFu9xwvodj3xVkAHBVmuJSXhEUrt4oxQVlAYCU5rIoW/LcxdUEq9KgLACQ0hCXyuWGUxq5VC43BIBL0zyKFpcbpmmD+ftVu9wQAC4NX6IDgC4gLgDQBcQFALqAuABAFxAXAOjCP+aF+2C3sbpdAAAAAElFTkSuQmCC" alt="" />
我在函数里面有嵌套了一个函数，当我向外层函数传递一变量的之后，并赋值给 a ，我们发现 a 变成了一个函数对象，而我再次为这个函数对象传参的时候，又获得了内部函数的返回值。我们知道，按照作用域的原则来说，我们在全局作用域是不能访问局部作用域的。但是，这里通过讨巧的方法访问到了内部函数。。
下面我们继续看一个例子：
def wai_hanshu():
a = []
def nei_hanshu(canshu):
a.append(canshu)
return a return nei_hanshu a = wai_hanshu()
print a(123)
print a(321)
aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAARgAAAAvCAIAAAC35EJ6AAAB+UlEQVR4nO3cy3HCMBhF4b8sNRSVAR1olyqyRftUwcYdpAlnEZDfL+aKkaPzrRJAssnMGYNtxdpX3L19hmbx6ei/4kvz6qQ9vHub2ZkC9lDrJ7iLf9Nbeue2SrP43k26mbu3i9m1nL9y9Bezq7nvZ/XF7SH+B21IQKUICRAgJECAkAABQgIECAkQICRAYBBS9GZmZm7lYuuGJri/ObhSg5oMQwqvFzTUhEBIqMhGSNH3jizpaJOON89D2OQIREioy3JIj0hSIE34eD4bvZm/tdGnz4BNcIOUCAl1WT8iRd/lsfTz7AOEhLrsD6nTBNc7HRH9zKkFQkJdDoc0rGjphYSEuhwLKfqlU+OjVxIS6nIgpCa43pmHMDjZMC6MkFCXzbN26cxd7/d0zbZ7bPQJkJBQF+5sAAS41w4QICRAgJAAAUICBAgJECAkQICQAAFCAgTUF2Tz4VIvCpZpqXk+3HyEEmVaar5qOmo683TraScICeXJtNR8xXjUbTJz7xZZQsI5ZFpqvs9j1O6ttC0hoUyZlppvmh81mZmQcA6ZlprvMxw1mZmQcBqZlprv1I2am5mQcBrypeabRc2MGs3MdyScjnypea+TJeNR6zPzP1xxAto7G+a/QGlwZwMKxr12gAAhAQKEBAgQEiBASIAAIQEChAQIEBIg8Au5I5F96BtFQQAAAABJRU5ErkJggg==" alt="" />
可以看出函数位于外部函数中的列表 a 竟然改变了。要知道为什么，就要先知道什么是python的命名空间，而命名空间就是作用域表现的原因，这里我简要说明一下。
引入命名空间的主要原因还是为了避免变量冲突，因为python中的模块众多，模块中又有函数，类等，它们都要使用到变量。但如果每次都要注意不和其他变量名冲突，那就太麻烦了，开发人员应该专注于自己的问题，而不是考虑别人写的程序中用到了什么变量，所以python引入了命名空间。命名空间分为模块层，模块内又分为全局作用域和局部作用域，用一个图来表示的话：
aaarticlea/png;base64,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" alt="" />
模块之间命名空间不同，而里面还有全局作用域和局部作用域，局部作用域之前还能嵌套，这样就能保证变量名不冲突了。这里顺便补充一下，可以通过 __name__ 属性获取命名空间的名字：
aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAALgAAABXCAIAAAA4QxjHAAADQ0lEQVR4nO2dUZKkIAyGuXWfpU+zt9nnvQHzsLtdTkIkjhgDfl9NWYrphml+QwxYlvf7XQF6FIQCHhAKuEAo4AKhgAuEAi4QCrhoC+VVypnCPV4H7W+iHP2/Vsf0KBdqJQC3HBGEk72hZ2KtIJTRdGKUkVp5lX9/umRb3izc/wa90/z4d8p3dHnXsmm8Kv1gdrBf0X0vtsJmv7DWtiBOexQtCLEVNstrJdCj/LdrHJ4USrcWm5NCsTzNeoTHKGsJxVnLAoTf9QQLpacYq9cZegSBeRQdZm53xOGhYNYKU3x+pRu6bneE/UPGnZo0MztJUu5R5BOK484W4sknFEgJQgEX4ZOCMCeLTgrCaBadFITRhKfwuw1S2QtxypNBf056I4zwSUFPm76rQezowicnTMNI51Hqbk9rp1JbQnnOXF0YGWMUSyiWm3nyXF0YGe969sWhCxl6AkiXR9GzcdaYsjX7nNVfAkMgMwsugoRieYKYwPPe2tcAjwIu2kIppc57gU3d+LSYHiXytx5eF0IZjulR5mXqxqeFGAVcjBfK3xDh89c81S2phBrJuMSjfHq6bgYCoQZtvz1sfgpuJE4on1NNT2MdIpQkhArF8hMIJT9Jhx7rFNzFVcFs3QhlqxUR5+6UVGOcglvg9hhceIUiLv2mP7ju0r+3dqh4FHCCUMBFihVurAXJT+iaWQQxL6Gr8BHKvAQ912MtOtwp0csTx65ZFGsidyoKa1JmQp8UtH5Q/euLrbAZrpVuRWFNSkvok4InhTJ8IfROT2unEtOktKSIUY56lFFYQrHcTECT0nLPXU9TGeLQ4+dPXsr74tCFDD2S6/Ioomu1997uCHvt5M8IRVdqjSmHmrQqZGbBxWpCsTyBLlyv9ktZTShwETc/KcjygFkY86Tgmc5GKFNw7EnB4Z2KSmbhWIxCvz6WHy6F1OVdy6YxzMIYj6IFIbbCBq1MR6hQLE8D+bnHo8B0/FAoTWWIQ4aelTicme2GrtsdYc+4My+k8MEFQgEXCAVcIBRwkeJJQchPxrdrQEIyvq8HEpLxDWCQkIzvFISE4FHABTEKuOCuB1yQRwEXZGbBBUIBFwgFXJTfAA7KLwAH5Q+Agy+C+cS+kyeASAAAAABJRU5ErkJggg==" alt="" />
主文件的命名空间是叫做 '__main__'，而模块的命名空间就是模块名。
作用域的诞生，是因为当python在寻找一个变量的时候，首先会在当前的命名空间中寻找，如果当前命名空间中没有，就到上一级的命名空间中找，以此类推，如果最后都没找到，则触发变量没找到的异常。
我们之前一直说：全局作用域无法访问局部作用域，而局部作用域能够访问全局作用域就这这个原因。而当我在局部作用域创建了一个和外面同名的变量时，python在找这个变量的时候首先会在当前作用域中找，找到了，就不继续往上一级找了。
在早期的python版本时，局部作用域是不能访问其他的局部作用域的，只能访问全局的，而现在的版本都是依次向上一级找，这里就提一下。
也就是因为这个特性，我们可以在内部函数中访问外部函数中的变量，这也就是所谓的闭包了。
注意：这里要做好对象之间的区分，例如：
def wai_hanshu():
a = []
def nei_hanshu(canshu):
a.append(canshu)
return a return nei_hanshu a = wai_hanshu() # 我创建了一个对象
b = wai_hanshu() # 我又创建了一个对象
print a
print b
print a(123)
print b(321)
aaarticlea/png;base64,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" alt="" />
在这里，我们虽然都是操作 wai_hanshu 中的变量，但是 a 和 b 完全是两个对象，它们所在的内存空间也是不同的，所以里面的数据也是独立的。要注意不要搞混。
装饰器
其实装饰器就是在闭包的基础上多进行了几步，看代码：
def zsq(func): # 装饰函数
def nei():
print '我在传入的函数执行之前做一些操作'
func() # 执行函数
print '我在目标函数执行后再做一些事情'
return nei def login(): # 被装饰函数
print '我进行了登录功能' login = zsq(login) # 我将被装饰的函数传入装饰函数中，并覆盖了原函数的入口 login() # 此时执行的就是被装饰后的函数了
aaarticlea/png;base64,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" alt="" />
在看这段代码的时候，要知道几件事：
1.函数的参数传递的其实是引用，而不是值。
2.函数名也是一个变量，所以可以重新赋值。
3.赋值操作的时候，先执行等号右边的。
只有明白了上面这些事之后，再结合一下代码，应该就能明白什么是装饰器了。所谓装饰器就是在闭包的基础上传递了一个函数，然后覆盖原来函数的执行入口，以后调用这个函数的时候，就可以额外实现一些功能了。装饰器的存在主要是为了不修改原函数的代码，也不修改其他调用这个函数的代码，就能实现功能的拓展。
而python觉得让你每次都进行重命名操作实在太不方便，于是就给出了一个便利的写法：
def zsq(func):
def nei():
print '我在传入的函数执行之前做一些操作'
func() # 执行函数
print '我在目标函数执行后再做一些事情'
return nei @zsq # 自动将其下面的函数作为参数传到装饰函数中去
def login():
print '我进行了登录功能' login()
aaarticlea/png;base64,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" alt="" />
这些小便利也叫做python的语法糖，你可能在很多地方见过这个说法。
带参数的装饰器：
def zsq(a):
print '我是装饰器的参数', a
def nei(func):
print '我在传入的函数执行之前做一些操作'
func() # 执行函数
print '我在目标函数执行后再做一些事情'
return nei @zsq('')
def login():
print '我进行了登录功能'
aaarticlea/png;base64,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" alt="" />
相当于： login = zsq(123)(login) ，所以在这里没有调用就执行了。
装饰器的嵌套：
这里就不完整写个例子了：
@deco1(deco_arg)
@deco2
def func():
pass
相当于： func = deco1(deco_arg)(deco2(func))
也就是从上到下的嵌套了。
关于闭包和装饰器就先讲到这里，以后有需要再补充。