闭包函数
闭包:定义在内网函数,包含对外部作用域而非全局作用域
范围:一个函数套用1或n个函数
from urllib.request import urlopen  #urlopen模块 作用:爬网页
#闭包函数,内部get函数调用外部page函数
def page(url):                                  #调用url
    def get():                                  #下载
        return urlopen(url).read()              #爬网页
    return get                                  #返回url值
baidu=page("http://www.baidu.com")              #函数page的值,手动写的url(url可变)
#print(baidu.__closure__[0].cell_contents)      #看oldboy函数包裹的元素
#print(baidu.__closure__)                       #看oldboy函数有几个值
print(baidu())                                  #显示百度网页
 
#如下效果相同,不是闭包函数,不灵活,(不能写baidu=page("http://www.baidu.com")的形式,)
def get(url):                       #下载
    return urlopen(url).read()
print(get("http://www.baidu.com")) #定义url    
#显示返回网页

装饰器
装饰器:装饰代码
必须遵守2个原则
最好不要修改源代码
最好不要修改调用方式
调用方式
functools模块(保存源代码的注释,更新到装饰后的程序)
import time
def timer(func):                    #func相等于index
    def wrapper(*args,**kwargs):    #wrapper等于indiex 所有要赋值
        start_time=time.time()      #计算第一次执行时间
        res=func(*args,**kwargs)    #定义func的值给res
        stop_time=time.time()       #计算第二次执行时间
        print("run time is %s" %(start_time-stop_time))
        return res                   #定义子函数的返回值
    return wrapper                  #返回子函数的值
@timer                  #index=timer(index) 注:把正下方的函数值给timer
def index():
    time.sleep(3)                    #沉睡3秒
    print("welcome to index")
index()    #显示是装饰后的值
#3秒后显示如下
#welcome to index
#run time is -3.0002331733703613
(函数增加功能,用户认证通过后执行函数,否则提示报错信息)
def Gavin(guolm):
    aa = ["guolm", "admin_1234"]
    def wrapper(*args,**kwargs):
        select= input("peales your writer your user>>>:")
        if select==aa[0]:
            print("ok")
            select1 = input("peales your writer your pass>>>:")
            if select1 ==aa[1]:
                res=guolm(*args,*kwargs)
                return res
            else:
                print("pass error")
        else:
            print("user error")
    return wrapper
@Gavin
def guolm():
    print("hello man")
    return guolm
guolm()                            #相当guolm= Gavin(guolm) 获取

用户认证+第二次不需要输入认证信息
logon_user={"user":None,‘STATUS‘:False}
def auth2(driver="file"):
    def ahth(func):
        def wrapper(*args,**kwargs):
            if driver=="file":
                if logon_user["user"] and logon_user["status"]:   #如果user有值并且statis是True,继续执行,#注释第一遍执行时,值不存在,所以执行else,第二次循环则成立
                    res=func(*args,**kwargs)                      #定义了函数func可n个元组,列表和n个字典
                    return res                                    #第三层函数的返回值
                else:
                    name=input(">>>:")
                    password=input(">>>:")
                    if name == "egon" and password == "123":    #如果认证成立继续执行
                        logon_user["user"]="egon"               #改变logon_user的user值, 为上个if判断做铺垫
                        logon_user["status"]=True               #改变logon_user的status值,为上个if判断做铺垫
                        res=func(*args,**kwargs)
                        return res                              #第三层函数的返回值
                    else:
                        print("error")
            elif driver == "mysql":
                print("show mysql")
                return func(*args,**kwargs)
            elif driver=="ldap":
                print("=====ldap认证")
            else:
                print("无效认证")
        return wrapper
    return  ahth
@auth2("file")                                  #index函数值为file,执行如下函数#相当于调用auth2下的ahth下的wrapper函数
def index():
    print("welcome to index page")
@auth2(driver="mysql")                          #home("egon")函数值为mysql,执行如下函数
def home(name):                                 #相当于调用auth2下的ahth下的wrapper函数
    print("%s welcome to home page" %name)      #name是 输入home("egon")的传参 就是egon
index()         #wrapper
home("11")       #输入11也能实现 有点不懂

迭代器
为什么要有迭代器?    对于没有索引的数据类型,必须提供一种不依赖索引的迭代方式
迭代的概念:    每次执行的结果作为下一次迭代的初始值
优点 : 提供一种不依赖下标的迭代方式,且迭代器更省内存空间(因为每次读取1行)
缺点:  不能获取迭代器对象的长度,且不如序列类型取值灵活,是一次性的,只能向后取值,不能向前
for循环也属于迭代器

可迭代的对象: 能执行.__iter__()方法为True
迭代器对象:能执行.__iter__()方法为True和执行__next__()是方法为True
可迭代对象: 只有__iter方法, 执行该方法可得到迭代器对象,只有可使用__next__方法

#数字不是迭代对象
#只是文件是迭代器,其他都可迭代对象

[1,2].__iter__()                #列表
"hello".__iter__()              #字符串
(1,2,).__iter__()               #元组
{"a":"1","b":"2"}.__iter__()    #列表
{1,2,3}.__iter__()              #集合

f=open("a.txt","w")          #文件
f.__iter__() 
#判断是否为可迭代对象
print(isinstance([1,2],Iterable))                 #返回True
print(isinstance("hello",Iterable))               #返回True
print(isinstance((1,2,),Iterable))                #返回True
print(isinstance({"a":"1","b":"2"},Iterable))    #返回True
print(isinstance({1,2,3},Iterable))                #返回True
print(isinstance(f,Iterable))                #返回True
#判断是否为迭代器对象
print(isinstance([1,2],Iterator))                 #返回False
print(isinstance("hello",Iterator))               #返回False
print(isinstance((1,2,),Iterator))                #返回False
print(isinstance({"a":"1","b":"2"},Iterator))    #返回False
print(isinstance({1,2,3},Iterator))               #返回False
print(isinstance(f,Iterator))                      #返回True

例如:
iter确定是迭代器  next取出值
i=[1,2,4].__iter__()

print(i)
print(i.__next__())                            #列表的值有3个 执行next每次只能取一个值
print(i.__next__())
print(i.__next__())
print(i.__next__())                            #因为只有3个值,执行4个会报错
#####
<list_iterator object at 0x0000003FC1E0E2E8>   #迭代器的内存地址 
1
2
4
或
dic={"a":1,"b":2,"c":3,}
i=dic.__iter__()            #确定dic可迭代
while True:
    try:                    #尝试实现如下信息
        key=i.__next__()    #迭代i的值给key
        print(dic[key])
    except StopIteration:   #except是抛出异常 遇到异常StopIteration,执行break
        break
 

生成器yield
yield的功能:
1    使用yield把函数变成迭代器 ,(相当于为函数封装好__iter__和__next__)
2    yield能返回多次,每次返回都会讲函数暂停,下一次next会从上一次暂停的位置继续执行,而return返回一次值,函数就终止

生成器操作
def foo():
    print("first")
    yield 1         #之前的值
    print("second")
    yield 2
    print("fifth")
g=foo()
print(g)            #看g的内存地址
print(next(g))
print(next(g))
#print(next(g))   #因为fifth没有加生成器yield 使用迭代器执行会保存
#或如下执行
for i in g:
    print(i)

生成器中使用计数器
def counter(n):
    print("start")
    i = 0
    while i< n :
        yield i
        i+=1
    print ("end")
g=counter(3)        #g是函数调用

for i in g:          #for循环显示生成器的值
    print(i)
#显示
start
0
1
2
end
显示文件,执行内容
#1,创建a.txt文件
#2执行python
#3,在db文件中输入值,最后一行开始计算,包含python的行会显示,不包含的行不显示
import time             #时间模块
def tail(file):
    with open(file,encoding="utf-8") as f:  #读取file(函数1定义的file),读取为utf-8
        f.seek(0,2)                         #文件最尾部操作
        while True:
            line=f.readline().strip()
            if line:                      #如果line值成立,则...
                yield line                #返回line值,并再次从新执行函数
            else:
                time.sleep(0.2)           #沉睡0.2秒
def grep(pattern,lines):                  #定义了2个参数
    for i in lines:
        if pattern in i:                  #pattern相当于python
            print(i)
g=grep("python",tail("a.txt"))          #g= grep函数的第二个参数是tail函数和tail调用文件,a.txt可改
for i in g:                             #循环显示值
    print(i)

(随着python解释器的启动而产生)

    print(sum)
    #<built-in function sum>    #内置函数
     
    import builtins            #查看内置参数的模块
    for i in dir(builtins): #查看有哪些内置函数
    print(i)

1.2.    全局名称空间

    #文件执行会产生全局名称空间,指定是文件级别定义的名字都会放入改空间
    #如下全是全局定义, 如下有小区别
     
    import time #模块级别定义
    name="guolm" #文件级别定义
    def func(): #函数级别定义
    print("hello man")
    print(func())
    class foo: #类级别定义
    pass

2. 局部作用域:

    范围:    局部名称空间
    有效期:局局有效,在局部可用, 函数调用时有效,调用结束后失效
    查找顺序:         局部名称空间 -->全局名称空间-->内置名称空间
    x=1000
    def func(c):
    x=2
    print(locals())     #查看局部名称空间
    func(1)
    {‘x‘: 2, ‘c‘: 1}        #这是局部名称空间

2.1.   局部名称空间

如下对比 memoryview比默认方式速度快的一个等级
import time
#默认方式 原内存空间垃圾回收,开辟新内存空间,
for n in (200000,400000):
data=b"x"*n
start = time.time()
b=data
while b:
b=b[1:]
print("memoryview",n,time.time()-start)
#memoryview 200000 1.3159432411193848 #表示1.3秒
#memoryview 400000 5.632980585098267   #表示5.6秒
print("========================================")
#memoryview在原内存空间直接修改
for n in (200000,400000):
data=b"x"*n
start = time.time()
b=memoryview(data)
while b:
b=b[1:]
print("memoryview",n,time.time()-start)
#memoryview 200000 0.04102897644042969 表示0.04秒
#memoryview 400000 0.08105683326721191 表示0.08秒