名称空间、作用域、闭包、装饰器、迭代器、生成器

--名称空间与作用域
名称空间：是存放名字的地方准确的说名称空间是存放名字与变量值绑定关系的地方
内置名称空间：在python解释器启动时产生，存放一些python内置的名字
全局名称空间: 在执行文件时产生，存放文件级别定义的名字
局部名称空间：在执行文件的过程中，如果调用了函数，则会产生该函数的局部名称空间，用来存放该函数内定义的名字，该名字在函数调用时生效，在函数调用结束后失效
加载顺序：内置--》全局--》局部
名字的查找顺序 局部--》全局--》内置

max=1
def foo():
    max=2
    print(max)
foo()
#结果：2
#先找局部的max=2 ，如果将max=2注释掉 找foo（）外层的 max=1，max=1注释掉，max=内置的函数

max=1
def foo():
    #max=2
    print(max)
foo()
#结果：1

#max=1
def foo():
    #max=2
    print(max)
foo()
#结果：<built-in function max> 内置变量max

作用域：变量或函数作用的范围
全局作用域：全局存活，全局有效：查看全局作用域的函数 globals()

x=1
def f1():
    def f2():
        def f3():
            def f4():
                print(x)
            f4()
        f3()
    f2()
f1()
//1                         

局部作用域：临时存活，局部有效：locals()

#优先掌握：作用域关系，在函数定义时就已经固定
# ，于调用位置无关,在调用函数时，必须回到函数原来定义的位置去找作用域关系

x=1
def f1():
    x=2
    def f2():
        print(x)
    return f2
func = f1()
def f3():
    x=33333
    func()#调用时必须回到函数原来定义的位置找作用域 f1中的f2按照名称空间原则 x=2
f3()    

--闭包
闭包：函数内的函数中对外部作用域名字的引用，而不是对全局作用域名字的引用

x=1
def f1():
    x=11111111111
    def f2():
        print(x)
    return f2

func=f1()    

--装饰器
1、开放封闭原则：对扩展是开放的，对修改是封闭的
2、装饰器：装饰它人的工具，装饰器本身可以是任意可调用的对象，被装饰的对象本身也可以是任意可调用的对象
2.1 装饰器的遵守原则：1 不修改被装饰对象的源代码 2 不修改被调用的调用方式
2.2 装饰器的目的是：在遵循1和2的原则下，为其他新功能函数添加

#@装饰器名，必须在被装饰对象的正上方，并且是单独一行

--无参
import time 
def timmer(func):#= func=index
    def wrapper():
        start=time.time()
        func()
        stop = time.time()
        print(%s(stop-start))
    return wrapper

#timmer(func) = 'func=index' 和wrapper()
@timmer #index = timmer(index)
def index():
    time.sleep(3)
    print('index')

@timmer #home = timmer(home)
def home():
    time.sleep(3)
    print('home')

index()
#@timmer-->1)index=timmer(index)-->func=1)index | 1)index = wrapper
# index()=warpper()
home()

--改进
#装饰器改进，多了调用时传入的参数和return

import time
def timmer(func):#= func=index
    def wrapper(*args,**kwargs):
        start=time.time()
        res = func(*args,**kwargs)
        stop = time.time()
        print('%s'%(stop-start))
        return res
    return wrapper
#timmer(func) = 'func=index' 和wrapper()

@timmer #index = timmer(index)
def index():
    time.sleep(3)
    print('index')


@timmer #home = timmer(home)
def home(name):
    time.sleep(3)
    print('home')
    return 123

#index()-->@timmer-->1)index=timmer(index)-->func=1)index | 1)index = wrapper
# index()=warpper()
res1 = home('egon')
print(res1)

--带参

current_user = {'user':None}
#多加了一层闭包
def auto(a_type='file'):
    def demo(func):
        def wapper(*args,**kwargs):
            if a_type == 'file':
            #第一次登陆验证，第二次不用验证
                if current_user['user']:
                    return func(*args,**kwargs)
                    inp = input('username：').strip()
                    inp2 = input('password:').strip()
                    with open('user', 'r') as f_read:
                        user_dic = eval(f_read.read())
                    if inp in user_dic and inp2 == user_dic[inp]:
                        current_user['user'] = True
                        res = func(*args,**kwargs)
                        return res
                    else:
                        print('error')
                else:
                    print('not valid auth_type')
        return wapper
    return demo

@auto(a_type='file')
def login():
    print('welcome')
@auto(a_type='mysql')
def home(name):
    print(name)
login()
home('egon')  

对于装饰器的使用，我们只需要记住

def auth(func):
    def inner(*args,**kwargs):
        #需在执行函数之前执行的内容，验证等。

        # 执行视图函数
        response = func(request,*args,**kwargs)
        return response
    return inner    

--迭代器
#迭代:是一个重复的过程,每一次重复,都是基于上一次的结果而来
#while True: #是单纯的重复不属于迭代
#平时我们取含有索引的对象时可以写成这样

l = ['a','b','c','d']
count =0
while count <len(l):
print(l[count])
count+=1

#迭代器
#可迭代的对象iterable：对象下有__iter__方法：对象.__iter__，该对象就是可迭代对象(字符串、列表、元组、字典、集合、文件都是可迭代对象)

s = 'hello'
l = ['a','b','c','d']
t =('a','b','c','d')
dic = {'name':'egon','sex':'m','age':18}

#
#迭代器对象：可迭代对象执行内置的__iter__方法，得到的结果就是迭代器对象

dic = {'name':'egon','sex':'m','age':18}
i= dic.__iter__()
print(i)

#不依赖索引的取值方式

l = ['a','b','c','d']
dic = {'name':'egon','sex':'m','age':18}
iter_dic = iter(dic)
while True:
    try:
        k=next(iter_dic)
        print(k,dic[k])
    except StopIteration:
        break