标签：pass 函数 home ... -- yield pytho 这一 闭包
又名name space, 顾名思义就是存放名字的地方，存什么名字呢？举例说明，若变量x=1，1存放于内存中，那名字x存放在哪里呢？名称空间正是存放名字x与1绑定关系的地方
名称空间共3种，分别如下:
1.locals: 是函数内的名称空间，包括局部变量和形参
2.globals: 全局变量，函数定义所在模块的名字空间
3.builtins: 内置模块的名字空间
有名称空间才有作用域
例子:
def outer_function(): b = 20 def inner_func(): c = 30 a = 10
在这个例子中，名称a在全局名称空间中，名称b在函数outer_function的局部名称空间，名称c则在函数inner_func的局部名称空间。
当我们在函数inner_func时，c是个局部的名称，b是个非局部的名称，而a则是个全局的名称。在函数inner_func中，我们可以对c进行读取操作和赋值操作，而只能对b和a进行读取操作。当对b进行赋值时，一个新的名称将会被创建，这个新的名称处于inner_func函数局部名称空间中。对a进行赋值时也会在局部名称空间中创建一个新的名称。
def outer_function(): a = 20 def inner_function(): a = 30 print(‘a = %s‘ % a) inner_function() print(‘a = %s‘ % a) a = 10 outer_function() print(‘a = %s‘ % a) 输出: a = 30 a = 20 a = 10
在函数inner_function中，我们对a进行了赋值操作，但函数outer_function中的a仍然为20，全局名称空间中的a则仍然为10。
为了在函数作用域中对全局的名称进行读取或者赋值操作，需要将这个名称声明为global。
def outer_function(): global a a = 20 def inner_function(): global a a = 30 print(‘a = %s‘ % a) inner_function() print(‘a = %s‘ % a) a = 10 outer_function() print(‘a = %s‘ % a)
输出:
a = 30
a = 30
a = 30
可以看到，通过global，我们在不同的作用域对全局名称a进行了赋值操作，最后在函数inner_function中对a的赋值也就是全局名称a的值。
作用域查找顺序:
LEGB 代表名字查找顺序: locals -> enclosing function -> globals -> __builtins__
level = ‘L0‘ n = 22 def func(): level = ‘L1‘ n = 33 print(locals()) def outer(): n = 44 level = ‘L2‘ print(locals(),n) def inner(): level = ‘L3‘ print(locals(),n) #此外打印的n是多少？ inner() outer() func()
闭包的意义：返回的函数对象，不仅仅是一个函数对象，在该函数外还包裹了一层作用域，这使得，该函数无论在何处调用，优先使用自己外层包裹的作用域
闭包函数必须满足两个条件:
1.函数内部定义的函数
2.包含对外部作用域而非全局作用域的引用
例1:以下仅仅在函数内部定义了一个函数,但并非闭包函数.
def outer(): def inner(): print("inner func excuted") inner() # 调用执行inner()函数 print("outer func excuted") outer() # 调用执行outer函数 ####输出结果为########## inner func excuted outer func excuted
例2:以下在函数内部定义了一个函数，而且还引用了一个外部变量x,那么这个是闭包函数么?答案：不是
x = 1 def outer(): def inner(): print("x=%s" %x) # 引用了一个非inner函数内部的变量 print("inner func excuted") inner() # 执行inner函数 print("outer func excuted") outer() #####输出结果######## x=1 inner func excuted outer func excuted
例3:显然,下面实例满足闭包函数的条件。现在，你应该清楚,作为一个闭包函数,必须得满足上述的两个条件,缺一不可。
def outer(): name = ‘alex‘ def inner(): print("在inner里打印外层函数的变量",name) return inner f = outer() f()
装饰器：外部函数传入被装饰函数名，内部函数返回装饰函数名。
特点：1.不修改被装饰函数的调用方式 2.不修改被装饰函数的源代码
不带参数装饰器:
user_status = False # 用户登录了就把这个改成True def login(func): def inner(): _username = "alex" # 假装这是DB里存的用户信息 _password = "abc123" # 假装这是DB里存的用户信息 global user_status if user_status == False: username = input("user:") password = input("pasword:") if username == _username and password == _password: print("welcome login....") user_status = True else: print("wrong username or password!") if user_status == True: func() return inner # henan() def home(): print("---首页----") def america(): print("----欧美专区----") def japan(): print("----日韩专区----") @login # henan=login(henan) def henan(): print("----河南专区----") henan() japan()
带参数的装饰器:
user_status = False # 用户登录了就把这个改成True def login(auth_type): def outer(func): def inner(*args, **kwargs): _username = "alex" # 假装这是DB里存的用户信息 _password = "abc123" # 假装这是DB里存的用户信息 global user_status if user_status == False: username = input("user:") password = input("pasword:") if username == _username and password == _password: print("welcome login....") user_status = True else: print("wrong username or password!") if user_status == True: func(*args, **kwargs) return inner # henan() return outer def home(): print("---首页----") def america(): print("----欧美专区----") # @login def japan(): print("----日韩专区----") @login(‘wx‘) # henan=login(henan) def henan(style): print("----河南专区----", style) # xx = login(‘qq‘) # print(xx) # henan = xx(henan) # print(henan) henan(‘oo‘)
例子:
现在有个需求，看列表[0, 1, 2, 3, 4, 5, 6, 7, 8, 9],要求你把列表里的每个值加1，你怎么实现？
a = [i+1 for i in range(10)] print(a)
这样的写法就叫做列表生成式.
在Python中，这种一边循环一边计算的机制，称为生成器：generator。
要创建一个generator，有很多种方法。第一种方法很简单，只要把一个列表生成式的[]改成()，就创建了一个generator：
如果要一个一个打印出来，可以通过next()函数获得generator的下一个返回值：
>>> L = [x * x for x in range(10)] >>> L [0, 1, 4, 9, 16, 25, 36, 49, 64, 81] >>> g = (x * x for x in range(1)) >>>next(g) >>>1 >>> next(g) <generator object <genexpr> at 0x1022ef630
创建L和g的区别仅在于最外层的[]和()，L是一个list，而g是一个generator.
所以，我们创建了一个generator后，基本上永远不会调用next()，而是通过for循环来迭代它，并且不需要关心StopIteration的错误。
generator非常强大。如果推算的算法比较复杂，用类似列表生成式的for循环无法实现的时候，还可以用函数来实现。
比如，著名的斐波拉契数列（Fibonacci），除第一个和第二个数外，任意一个数都可由前两个数相加得到：
这就是定义generator的另一种方法。如果一个函数定义中包含yield关键字，那么这个函数就不再是一个普通函数，而是一个generator
def fib(max): n, a, b = 0, 0, 1 while n < max: print(‘before‘) yield b # 把函数的执行过程冻结着这一步并且把b的值返回给外面 print(b) a, b = b, a + b n = n + 1 return ‘Done‘ f = fib(15) # turn function into generators for i in f: print(i)
这里，最难理解的就是generator和函数的执行流程不一样。
函数是顺序执行，遇到return语句或者最后一行函数语句就返回。
而变成generator的函数，在每次调用next()的时候执行，
遇到yield语句返回，再次被next()调用时从上次返回的yield语句处继续执行
yield VS return:
标签：pass 函数 home ... -- yield pytho 这一 闭包
原文地址：https://www.cnblogs.com/cnike/p/10662275.html
