迭代器生成器面向过程

Posted 2020-10-29 宋先生

目录：

一、装饰器

二、迭代器

三、生成器

四、面向过程

 

 

 

一、装饰器

　　　　　　 1、装饰器简介：　　　　　　　　　　　

　　　　　　　　　　　  软件一旦上线后，就应该遵循开放封闭原则，即对修改源代码是

　　　　　　　　　　封闭的，对功能的扩展是开放的也就是说我们必须找到一种解决

　　　　　　　　　　方案能够解决在不修改一个功能源代码以及调用方式的前提下，

　　　　　　　　　　为其加上新功能，而装饰器正好可以解决这个问题

　　　　　　 2、装饰器是什么:

　　　　　　　　　　 装饰器就是为被装饰对象添加功能的工具

　　　　　　3、定义：

　　　　　　　　　　 装饰即在不修改被装饰对象源代码与调用方式的前提下，为被装

　　　　　　　　　　 饰器对象添加功能，装饰器与被装饰对象均可以使任意调用的对

　　　　　　　　　   象，装饰器本质就是函数，被装饰对象也是函数　

　　　　　　4、无参装饰器

装饰器样式：

def timmer(func):
    #func=最原始的home
    def wrapper(*args,**kwargs):
        start_time=time.time()
        res=func(*args,**kwargs) #调用最原始的home
        stop_time=time.time()
        print(stop_time-start_time)
        return res
    return wrapper

运用：

import time
def outter(func):
　　def wrapper():
　　　　start_time=time.time()
　　　　func()
　　　　stop_time=time.time()
　　　　print(stop_time-start_time)
　　　　return wrapper

  @outter 

def index(): 
　　time.sleep(3) 
　　print(‘welcome to index page‘) 
def home(name):
　　time.sleep(5) 
　　print(‘welcome %s to home page‘ %name) 
index() 
home(‘baidu‘) 

　　　　　　　5、有参装饰器

import time
current_user={
    ‘username‘:None,
}
def auth(engine):
    def auth2(func)
        def wrapper(*args,**kwargs):
            if engine == ‘file‘:
                if current_user[‘username‘]:
                    print(‘已经登陆过了‘)
                    res=func(*args,**kwargs)
                    return res

                uname=input(‘用户名>>: ‘).strip()
                pwd=input(‘密码>>: ‘).strip()
                if uname == ‘egon‘ and pwd == ‘123‘:
                    print(‘登陆成功‘)
                    current_user[‘username‘]=uname
                    res=func(*args,**kwargs)
                    return res
                else:
                    print(‘用户名或密码错误‘)
            elif engine == ‘mysql‘:
                print(‘基于MyQL的认证‘)
            elif engine == ‘ldap‘:
                print(‘基于LDAP的认证‘)
        return wrapper
    return auth2



@auth(‘ldap‘) 
def index():
    time.sleep(1)
    print(‘welcome to index page‘)
    return 122


index() 

　　　　　　6、叠加多个装饰器

import time
current_user={
    ‘username‘:None,
    # ‘login_time‘:None
}

def auth(func):
    def wrapper(*args,**kwargs):
        if current_user[‘username‘]:
            print(‘已经登陆过了‘)
            res=func(*args,**kwargs)
            return res
        uname=input(‘用户名>>: ‘).strip()
        pwd=input(‘密码>>: ‘).strip()
        if uname == ‘egon‘ and pwd == ‘123‘:
            print(‘登陆成功‘)
            current_user[‘username‘]=uname
            res=func(*args,**kwargs)
            return res
        else:
            print(‘用户名或密码错误‘)
    return wrapper

def timmer(func):
    def wrapper(*args,**kwargs):
        start_time=time.time()
        res=func(*args,**kwargs)
        stop_time=time.time()
        print(stop_time-start_time)
        return res
    return wrapper

@timmer 
@auth
def index():
    time.sleep(1)
    print(‘welcome to index page‘)
    return 122

二、迭代器

　　　　　　1、什么是迭代器：

　　　　　　　　　　完成一个重复的过程，并且每次重复都是基于上一次的结果而来

　　　　　　2、可迭代对象：

　　　　　　　　　　但凡内置有__iter__方法的对象，都是可迭代对象

dic={‘x‘:1,‘y‘:2,‘z‘:3}
iter_dic=dic.__iter__()
print(iter_dic.__next__())
print(iter_dic.__next__())
print(iter_dic.__next__())
print(iter_dic.__next__())

s1={‘a‘,‘b‘,‘c‘}
iter_s1=s1.__iter__()
print(iter_s1.__next__())
print(iter_s1.__next__())
print(iter_s1.__next__())
print(iter_s1.__next__())

list1=[1,2,3]
iter_list1=list1.__iter__()
print(iter_list1.__next__())
print(iter_list1.__next__())
print(iter_list1.__next__())

 

　　　　　　3、迭代对象：

　　　　　　　　　　可迭代的对象执行__iter__方法得到的返回值就是迭代器对象

　　　　　　　　　　本身内置有__iter__和__next__方法，文件本身就是迭代器对

　　　　　　　　　　象

　　　　　 4、迭代器的优缺点：

　　　　　　　　　　优点：

　　　　　　　　　　　　1、提供了一种可不依赖于索引的取值方式

　　　　　　　　　　　　2、节省内存

　　　　　　　　　　 缺点：

　　　　　　　　　　　　1、取值麻烦，只能一个一个取，而且只能往后取

　　　　　　　　　　　　2、一次性，无法用len获取长度

　　　　　5、for循环原理分析：　　　　　　　

　　　　　　　　for 循环称之为迭代器循环，in后跟的必须是可迭代的对象for循环会执行in后

　　　　　　　　对象的__iter__方法，拿到迭代器对象、然后调用迭代器对象的__next__方法，

　　　　　　　　拿到一个返回值赋值　给line，执行一次循环体周而复始，直到取值完毕，for

　　　　　　　　循环会检测到异常自动结束循环

三、生成器

　　　　　　　1、函数内包含有yield关键字，再调用函数体代码，拿到的返回值就是一个生成

　　　　　　　　 器对象，生成器的本质就是迭代器，也就是说生成器的玩法就是一个生成对象　　　　

   def chicken(): 
　　print(‘=====>first‘)
    yield 1
    print(‘=====>sencond‘)
    yield 2
    print(‘=====>third‘)
    yield 3
obj=chicken()
res=obj.__next__()
print(res)

for item in obj:#会报出异常
    print(item)

1、iter_obj=obj.__iter__()，拿到迭代器
2、出发iter_obj.__next__()，拿到该方法的返回值，赋值给item
3、周而复始，直到函数内不在有yield，即取值完毕
4、for会检测到StopIteration异常，结束循环

总结yield：
1、为我们提供了一种自定义迭代器的方式，
   可以在函数内用yield关键字，调用函数拿到的结果就是一个生成器，生成器就是迭代器
2、yield可以像return一样用于返回值，区别是return只能返回一次值，而yield可返回多次
   因为yield可以保存函数执行的状态

　　　　　　自制range函数

def my_range(start,stop,step=1):
    n=start
    while n < stop:
        yield n
        n+=step

for item in my_range(5,10,2):
    print(item)

四、面向过程

　　　　　　1、面向过程的编程思想
    　　　　　　　　核心是‘过程‘二字，过程即解决问题的步骤，即先干什么，再干什么......
    　　　　　　　　基于面向过程编写程序就好比在设计一条流水线，是一种机械式的思维方式。

　　　　　　2、总结优缺点：
    　　　　　　　　优点：复杂的问题流程化，进而简单化
    　　　　　　　　缺点：修改一个阶段，其他阶段都有可能需要做出修改，牵一发而动全身，
　　　　　　　　　　　　　即扩展性极差
    　　　　　　　　应用：用于扩展性要求低的场景