一、名称空间
顾名思义就是存放名字的地方；举例：若变量X=1,1存放在内存中，是存放名字X与1绑定关系的地方。
名称空间有三种：
1.locals:函数内的名称空间，包括局部变量和形参
2.globals:全局变量，函数定义锁在模块的名字空间
3.builtins: 内置模块的名字空间
二、作用于的查找顺序
LEGB顺序
locals--->enclosing(外部嵌套函数的名称空间)--->globals--->builtins
三、闭包
即函数定义和函数表达式位于另一个函数的函数体内（嵌套函数）。而且，这些函数可以访问他们所在的外部函数中声明的所有局部变量、参数。当其中一个这样的内部函数在包含他们的外部函数之外被调用时，就会形成闭包。
闭包的意义：返回的函数对象，不仅仅是一个函数对象，在函数对象外还包含了一层作用于，这使得，该函数无论在何处调用，优先使用自己外层包裹的作用域。
def func(): n = 10 def func2(): print('func2:',n) return func2 f = func() print(f) f() >>>><function func.<locals>.func2 at 0x000001F9C4B1B9D8> >>>>func2: 10
为函数传参的两种方式：
方式一：直接把函数需要的参数定义成形参
方式二：利用闭包函数传参
def func():
x = 4
def func2():
print(x)
return func2
res = func()
print(res)
res()
四、装饰器
定义：定义一个工具，该工具是用来装饰其他函数的，来增加额外功能的。
为什么要用装饰器：在不修改被装饰器源代码对象以及调用方式的前提下，为被装饰对象添加新功能。
开放封闭原则：对拓展功能是开放的；对修改源代码是封闭的。
import time def index(x,y,z): time.sleep(3) print('index%s %s %s' %(x,y,z)) return 666 # print(index)-------<function index at 0x000001A2AD783E18> def outter(func1): # func = index的内存地址 def wrapper(*args,**kwargs): start = time.time() res = func1(*args,**kwargs) # index的内存地址 stop = time.time() print(stop - start) return res return wrapper index = outter(index) # outter的内存地址 # print(index)-----<function outter.<locals>.wrapper at 0x000001A2AF67BA60> res = index(3,5,6,) print('返回值----',res) # 结果 # >>> index3 5 6 # >>> 3.000042200088501 # >>> 返回值---- 666
语法糖：当需要同一个装饰器装饰不同的函数的时候，可以把装饰器写在最上面，在函数的上面单独一行@装饰器名字
import time def outter(func1): # func = index的内存地址 def wrapper(*args,**kwargs): start = time.time() res = func1(*args,**kwargs) # index的内存地址 stop = time.time() print(stop - start) return res return wrapper @outter def index(x,y,z): time.sleep(3) print('index%s %s %s' %(x,y,z)) return 666
装饰器模板
def outter(func): def wrapper(*args,**kwargs): # 1.调用原函数 # 2.增加新功能 res = func(*args,**kwargs) return res return wrapper
加了装饰器之后如果需要保持和原函数的属性一直，操作如下：应用wraps
import time from functools import wraps # 导入wraps功能 def timmer(func): '''计时器''' @wraps(func) # 自动将原函数func的属性赋值给wrapper def wrapper(*args,**kwargs): strat = time.time() res = func(*args,**kwargs) stop = time.time() print(stop - strat) return res # 手动将原函数的属性赋值给wrapper # 1.函数wrapper.__name__ = 原函数.__name__ # 2.函数wrapper.__doc__ = 原函数.__doc__ # 1.wrapper.__name__ = func.__name__ # 2.wrapper.__doc__ = func.__doc__ return wrapper @timmer def login_in(x): '''登入验证''' time.sleep(2) print('登入成功！',x) login_in(222) print(login_in.__name__) print(login_in.__doc__) # >>>登入成功！ 222 #>>>2.0001063346862793 # >>>login_in # >>>登入验证
有参装饰器
应用原因
# 由于语法糖的限制，outter函数只能有一个参数，并且函数知识用来接收被修饰对象的内存地址 def outter(func): # outter 的参数也不能改动 def wrapper(*args,**kwargs): # wrapper的参数不能改动 res = func(*args,**kwargs) return res return wrapper
如果outter需要接受多个参数时，在无参装饰器的基础上再套一层，为被装饰对象多传值
def auth(a,b,c): def outter(func): # outter 的参数也不能改动 def wrapper(*args,**kwargs): # wrapper的参数不能改动 res = func(*args,**kwargs) return res return wrapper return outter @auth(a = 111, b = 222, c = 333) def logn_in(x): pass
多个装饰器：
加载顺序是自下而上的；执行顺序是自上而下的。
五.迭代器
是指迭代（是一个重复的过程）取值的工具，基于上一次结果而继续的，单纯的重复不是迭代。
可迭代对象：但凡内置方法中有__iter__方法的都称为可迭代对象
迭代器对象：有__iter__()同时有__next__()方法
迭代器适用所有类型：（字符串、列表、字典、元组、集合、文件）
a = 'afsafacasd' a_iterator = a.__iter__() # 迭代器 while True: try: print(a_iterator.__next__()) except StopIteration: break
以下代码与上面的功能一样：
1.调出a.__iter__(),得到一个迭代器
2.调出迭代器下面的__next__()方法，拿到一个返回值赋值给k。
3.循环步骤2，直到异常出现，跳出循环。
a = 'afsafacasd' for k in a: print(k)
总结：
优点：①为序列和非序列类型提供了一种统一的取值方法；②惰性计算：迭代器对象表示的是一个数据流，可以只在需要时才去调用next来计算出一个值，就迭代器本身来说，同一时刻在内存中只有一个值，因而可以存放无限大的数据流，而对于其他容器类型，如列表，需要把所有的元素都存放于内存中，受内存大小的限制，可以存放的值的个数是有限的。
缺点：①除非取尽，否则无法获取迭代器的长度；②一次只能取一个值，如果取完了，需要重新调用迭代器才能够继续取值。
六、生成器
本质就是迭代器；是自定义的迭代器
def func(): print('第一次') yield 1 # yield 函数在运行时，遇到yield会停下来，
#将yield后面的值当做本次的调用结果返回 print('第二次') yield 2 print('第三次') yield 3 print('第四次') yield 4 g=func() res = next(g) print(res)
yield作为表达式的用法：
def dog(y): print('狗狗%s准备吃东西了'%y) while True: x = yield # yield 接收到的是send的过来的值，
# 但是一开始的时候必须send(None) print('狗狗%s吃了%s'%(y,x)) g = dog('小黑') g.send(None) g.send('包子') g.send('饼干') g.send('骨头')
七、三元表达式
语法格式： 条件成立返回的值 if 条件 else 条件不成立返回的值
列表生成式：l = [表达式 for i in 可迭代对象 if 条件]