Python学习-迭代器、生成器

迭代器

一、迭代器协议

1. 对象必须提供一个next方法，执行该方法要么返回迭代中的下一页，或者抛出一个Stoplteration异常，终止迭代。
2. 具有可迭代的对象。
3. 一种实现迭代器的的约定。（如for循环、sum、min、max等）使用迭代器协议访问对象。

二、Python中强大的for循环机制

for循环的本质：循环所有的对象，全部使用迭代器协议。只要能被for循环遍历的都有一个_iter_()方法。

其实，严格意义来说（字符串、列表、字典、集合、文件对象都是不可迭代对象），只不过是使用了for循环。调用了它们内部的_iter_方法，把它们变成可迭代的对象。

l = [1,2,3]
#下标访问
print(l[0])
print(l[1])
print(l[2])
print(l[3]) #超出边界报错，IndexError: list index out of range
#遵循迭代器协议访问方式
iter_test = l.__iter__()
print(iter_test)
print(iter_test.__next__())
print(iter_test.__next__())
print(iter_test.__next__())
print(iter_test.__next__()) #超出边界值，抛出异常StopIteration

#用while来模拟for循环
Test_iter = l.__iter__()
while True:
    try:
        print(Test_iter.__next__())
    except StopIteration:
        print("迭代结束！")
        break
注：for循环帮助处理异常。

生成器

　　一种数据类型，自动实现迭代器协议，就是可迭代协议。

　　两种表现方式

1. 函数

#生成器雏形
def test():
    yield 1
    yield 2
g = test()
print(g.__next__())
print(g.__next__())

运行结果：

1
2

 

　　2.生成器表达式

g =("egg %s"%i for i in range(5))
print(g)
print(g.__next__())
print(g.__next__())
print(g.__next__())
print(g.__next__())
print(next(g))
print(next(g))
print(next(g))

运行结果：

 

 print(next(g))
StopIteration
<generator object <genexpr> at 0x0000000001DFEDB0>
egg 0
egg 1
egg 2
egg 3
egg 4

 总结：

• 语法与常规函数类似，它们之间不同的是生成器使用yield返回一个值，而函数使用return返回值。
• 自动实现迭代器协议。
• 状态挂起，yield语句挂起生成器函数的状态，保留足够的信息，以便于下一次从当前位置执行。
• 生成器只能遍历一次。

例子：

{'name':'北京','population':30000}
{'name':'上海','population':35000}
{'name':'山东','population':30080}
{'name':'河北','population':30900}
{'name':'台湾','population':35600}
#统计上面文件中各个省所占的总人口的比例
def get_population():
    with open('人口普查','r',encoding = 'utf-8') as f:
        for i in f:
            yield  i
#以生成器的方式获取文件信息
g = get_population()
s1 = eval(g.__next__())['population']
print(s1)
all_pop  = sum(eval(i)['population'] for i in g)
print(all_pop)

for p in g:
    print('%s %%'%eval(p)['population']/all_pop)

 

　　3.三元表达式

name = "laj"
res = "SB" if name == "alex" else "shuaige"
print(res)
运行结果：
满足if条件，res为SB，不满足则为shuaige。
shuaige

　　4.列表解析

egg_list = []
for i in range(10):
    egg_list.append("egg %s"%i)
print(egg_list)
l1 =["egg %s"%i for i in range(10)]
print(l1)
l2 =["egg %s"%i for i in range(10) if i > 5]
print(l2)
l1 =["egg %s"%i for i in range(10) if i > 5 else i] #没有四元表达式，可以有两元 

运行结果：

['egg 0', 'egg 1', 'egg 2', 'egg 3', 'egg 4', 'egg 5', 'egg 6', 'egg 7', 'egg 8', 'egg 9']
['egg 0', 'egg 1', 'egg 2', 'egg 3', 'egg 4', 'egg 5', 'egg 6', 'egg 7', 'egg 8', 'egg 9']
['egg 6', 'egg 7', 'egg 8', 'egg 9']

 装饰器

本质就是函数。

装饰就是修饰，修饰一下其他的函数，添加附加功能。

两个原则：

1、不修改被修饰函数的调用方式。

2、不修改被修饰函数的源代码。

知识储备：

装饰器 = 高阶函数+闭包+函数嵌套

高阶函数

1、函数接受的参数是一个函数名

2、函数的返回值是一个函数名

3、只需满足其中一个条件就可以称为高阶函数。

import time
def foo():
    time.sleep(1)
    print('hello world')
def test1(func):
    print(func)
    start_time = time.time()
    func()
    stop_time = time.time()
    print("函数运行的时间是%s"%(stop_time-start_time))
test1(foo)

函数的嵌套

在函数内部定义函数

def father(name):
    def son():
        print("我的爸爸是%s"%name)
    son() #局部变量只能在局部调用
father("lqj")

闭包

函数作用域的一种体现

def father(auth_typer):
    def son():
        #print("我的爸爸是%s"%name)
        def grandson():
            print("我的爷爷是%s"%auth_typer)
        grandson()
    son() #局部变量只能在局部调用
father('xxoo')

搭建装饰器的框架

import time
def timer(func):
    def wrapper():
        start_time = time.time()
        res = func() #运行test
        stop_time = time.time()
        print('函数的运行时间为%s'%(stop_time-start_time))
        return res
    return  wrapper
@timer
def test():
    time.sleep(3)
    print('函数运行完毕')
    return '这是返回值'
#res = timer(test) #返回wraper的地址
#res() #执行wrapper
#test = timer(test) #返回wraper的地址
#test() #执行wrapper
#@timer 就相当于test = timer(test)
res = test()
print(res)

解压

a,b,c =  (1,2,3)
print(a,b,c)
a,*_,c = (1,2,3,4,5,6)
print(a,c)

两个值交换

f1 = 1
f2 = 2
f1,f2 = f2,f1
print(f1,f2)

 

def father(auth_typer):
def son():
#print("我的爸爸是%s"%name)
def grandson():
print("我的爷爷是%s"%auth_typer)
        grandson()
    son() #局部变量只能在局部调用
father('xxoo')