python第四周迭代器生成器序列化面向过程递归

第一节装饰器复习和知识储备------------

第一节装饰器复习和知识储备------------
def wrapper(*args,**kwargs):
    index(*args,**kwargs)
# * 的作用是把位置参数打散传值到args=[a,b,c]
# **的作用是把关键字参数打散传值到kwargs=[a,b,c]
def index(a,b,c):
    print(a,b,c)
wrapper('tt','pppp',c='vvv')
 
二:函数可以被当做数据传递.
 
函数可以当做参数传给另外一个函数
一个函数的返回值也可以是一个函数
 
三.名称空间和作用域.
名称空间分为三种:
内置名称空间:python解释器启动则生效
全局名称空间:执行python文件时生效
局部名称空间:调用函数时,临时生效,函数调用结束时失效
 
加载顺序==>  内置 --->全局 --->局部名称空间
 
名字查找的顺序是: 局部 -->全局 --->内置名称空间
 
作用:
分两种:
全局作用域         全局存活
和局部作用域.	   临时存活  函数内部使用 局部有效

第二节闭包函数.函数的作用域关系在定义阶段就有了,和调用阶段无关.

第二节闭包函数.函数的作用域关系在定义阶段就有了,和调用阶段无关.
 
定义在函数内部的函数叫闭包函数.
 
包含对外部作用域而不是全局作用域的引用.
x=1
def outter():
    x=2
    def inner():
        print(x)
    return inner
f=outter()
f()
 
#获取的f不止inner函数,还有外面的一层作用域.
 
from urllib.request import  urlopen
def outget(url):
    def get():
 
        return urlopen(url).read()
    return get
 
baidu=outget('http://www.baidu.com')
print(baidu())
 
第三迭代器.===========不依赖于索引取值的方式
一般迭代可以有索引的
l=[1,2,3,4]
i=0
while i < len(l):
    print(l[i])
    i+=1
 
print('hello'.__iter__())
print('hello'.__iter__)
 
可迭代的对象.只要对象内只有__iter__方法,obj.__iter__
 
可迭代对象有:字符串  列表  元祖   字典  文件
 
迭代器对象对象既内只有__iter__方法,又内置有__next__方法.   文件是迭代器对象
 
可迭代对象不一定是迭代器对象,迭代器对象一定是可迭代对象
 
dic={'aa':1,'bb0':2,'cc':3}
 
dc=dic.__iter__()
 
dc.__next__
 
#可迭代对象执行了__iter__()方法后就变成了迭代器对象.
 
#######获取迭代器的下一个值
dic={'aa':1,'bb0':2,'cc':3}
 
dc=dic.__iter__()
 
print(dc.__next__())
----------------------不依赖于索引的取值.
with open('tt2.txt','r',encoding='utf-8') as f:
    print(next(f))
    print(next(f))
    print(next(f))
 
dic={'aa':1,'bb0':2,'cc':3}
tt=dic.__iter__()
print(next(tt))
print(next(tt))
print(next(tt))
 
dic={'aa':1,'bb0':2,'cc':3}
dc=dic.__iter__()
 
while True:
    try:
        print(next(dc))
    except:
        break
 
=============第八迭代器下.
 
for就是系统的迭代器.
for循环会把可迭代对象,变为迭代器.
 
迭代器对象没有值,只有在next的时候才获取值.
这样更节省内存.
 
aa=range(1000000000)
tt=aa.__iter__()
 
print(tt.__next__())
print(tt.__next__())
print(tt.__next__())
很多字典列表变为迭代器对象了.
 
from collections import Iterable,Iterator
 
print(isinstance('hello',Iterable))
 
print(isinstance('hello',Iterator))
 
----------------第九生成器.只要定义函数内部出现yield关键字,
#name再调用该函数,将不会立即执行该函数代码,将会得到该结果就是生成器对象.
 
生成器的本质就是迭代器.return只能返回一次值.yield可以返回多次值.
 
def fc():
    print("111111111")
    yield 1
    print("2222")
    yield 2
    print("33333333")
    yield 3
 
g=fc()
 
print(g)
print(next(g))
print(next(g))
##############
<generator object fc at 0x02C944E0>
111111111
1
2222
2
 
yield的功能:
为我们提供了一种自定义迭代器的方式
 
对比return,可以返回多次值,挂起函数的运行状态.
 
一次yield对应一次next多了报错.
def fc():
    print("111111111")
    yield 1,2,'yyy'
    print("2222")
    yield 2
    print("33333333")
    yield 3
g=fc()
for i in g:
    print(i)
for i in g:
    print(i)
#第二次for循环不会取值. 一次就将for循环的值取完了.
 
=================10节生成器下
def my_range(start,stop,step):
    while start < stop:
        yield start
        start+=step
f=my_range(1,4,1)
 
print(next(f))
print(next(f))
print(next(f))
print(next(f))
print(next(f))
 
def my_range(start,stop,step):
    while start < stop:
        yield start  #这里获取到的是一个生成器,通过next()可以获取到生成器的值.
        start+=step
f=my_range(1,4,1)
# print(next(f))
# print(next(f))
# print(next(f))
for i in f:
    print(i)
 
-----------模仿grep 和tail的功能的实现
#tail 'tt2.txt'|grep '404'
#把每次tail的值传给greo_file函数
import time
def tailpath(f_ph):
    with open(f_ph,'r',encoding='utf-8') as f:
        f.seek(0,2)
        while True:
            line=f.readline()
            if line:
 
                yield line
            else:
                time.sleep(1)
def grep_file():
    lines=tailpath('tt2.txt')
    for line in lines:
        if '404' in line:
            print(line,'****')
            # break
grep_file()
 
----------------第二版
#tail 'tt2.txt'|grep '404'
#把每次tail的值传给greo_file函数
import time
def tailpath(f_ph):
    with open(f_ph,'r',encoding='utf-8') as f:
        f.seek(0,2)
        while True:
            line=f.readline()
            if line:
 
                yield line
            else:
                time.sleep(1)
def grep_file(patten,lines):
    for line in lines:
        if patten in line:
            print(line,'****')
            break
grep_file('404',tailpath('tt2.txt'))
 
---测试的写文件
with open('tt2.txt','a',encoding='utf-8') as a:
   a.write("aaaaaaaaaa\n")
 
   a.write("404fggggggggggggggg\n")
 
# print('404' in '404fggggggggggggggg')
----------------进化版
#tail 'tt2.txt'|grep '404'
#把每次tail的值传给greo_file函数
import time
def tailpath(f_ph):
    with open(f_ph,'r',encoding='utf-8') as f:
        f.seek(0,2)
        while True:
            line=f.readline()
            if line:
 
                yield line
            else:
                time.sleep(1)
def grep_file(patten,lines):
    for line in lines:
        if patten in line:
            yield line
gp=grep_file('404',tailpath('tt2.txt'))
 
# for g in gp:
#     print(g)
 
print(next(gp))

11. 节开始yield的另外一种使用方式.主要作用是给闭包函数传送多个值和接收多个值.

===========11节开始
------yield的另外一种使用方式.主要作用是给闭包函数传送多个值和接收多个值.
---------------------send的作用一个是给yield赋值,一个是往下走.
def eat(name):
    print('开始了 %s' %name)
    while True:
        food=yield
        print('%s 吃了 %s' %(name,food))
 
g=eat('egon')
g.send(None)
g.send('骨头')
 
---------------------- send给的是yield变量获取的的值,tt=g.send('')返回值是yield后面的值.
 
def eat(name):
    print('开始了 %s' %name)
    while True:
        food=yield 123
        print('%s 吃了 %s' %(name,food))
 
g=eat('egon')
g.send(None)
g.send('骨头')
print(g.send('骨头'))
 
g.send('骨头')
next(g)
 
----send的值给了赋值得的变量,send获取了yield的返回值.
 
开始了 egon
egon 吃了 骨头
egon 吃了 骨头
123
egon 吃了 骨头
egon 吃了 None
 
def eat(name):
    list_food=[]
    print('开始了 %s' %name)
    while True:
        food=yield list_food
        print('%s 吃了 %s' %(name,food))
        list_food.append(food)
 
g=eat('egon')
g.send(None) #或者next(g)
g.send('骨头')
print(g.send('shi'))
#-----
#开始了 egon
#egon 吃了 骨头
#egon 吃了 shi
#['骨头', 'shi']
 
----------一个函数多次传值.
def tt():
 
    while True:
        x=yield
        print(x)
 
g=tt()
g.send(None)
g.send(11)
g.send(2)
g.close()
 
---------------------send的作用一个是给yield赋值,一个是往下走. def eat(name): print('开始了 %s' %name) while True: food=yield print('%s 吃了 %s' %(name,food)) g=eat('egon') g.send(None) g.send('骨头') ---------------------- send给的是yield变量获取的的值,tt=g.send('')返回值是yield后面的值. def eat(name): print('开始了 %s' %name) while True: food=yield 123 print('%s 吃了 %s' %(name,food)) g=eat('egon') g.send(None) g.send('骨头') print(g.send('骨头')) g.send('骨头') next(g) ----send的值给了赋值得的变量,send获取了yield的返回值. 开始了 egon egon 吃了 骨头 egon 吃了 骨头 123 egon 吃了 骨头 egon 吃了 None def eat(name): list_food=[] print('开始了 %s' %name) while True: food=yield list_food print('%s 吃了 %s' %(name,food)) list_food.append(food) g=eat('egon') g.send(None) #或者next(g) g.send('骨头') print(g.send('shi')) #----- #开始了 egon #egon 吃了 骨头 #egon 吃了 shi #['骨头', 'shi'] ----------一个函数多次传值. def tt(): while True: x=yield print(x) g=tt() g.send(None) g.send(11) g.send(2) g.close()

第十二节.面向过程编程.

=======第十二节.面向过程编程.
import os
 
tt=os.walk(r'D:\PycharmProjects\wadsd')
 
print(tt)
print(next(tt))
 
#os.walk返回一个生成器
#next(tt) 返回三个值得元祖,第一个值当前目录,第二个值当前目录下的目录    第三个值 返回当前目录下的文件.
 
<generator object walk at 0x02A144E0>
('D:\\PycharmProjects\\wadsd', ['.git', '.idea', 'day1', 'day2', 'day3', 'day4'], ['11.txt', '文件.py'])
 
-----------打印目录下的文件的绝对路径
import os
def search(target):
    g = os.walk(r'D:\PycharmProjects\wadsd')
 
    for dirname,_,files in g:
        for file in files:
            abs_path=r'%s\%s' %(dirname,file)
            target.send(abs_path)
def opener():
    while True:
        abs_path=yield
        print(abs_path)
g=opener()
next(g)
search(g)
 
-------再写一遍
import os
def get_path(pp):
    g=os.walk(r'D:\PycharmProjects\wadsd\day4')
    for base_apth,_,files in g:
        abs_path='%s\%s' %(base_apth,files)
        pp.send(abs_path)
def pp():
    while True:
        abs_path=yield
        print(abs_path)
tt=pp()
next(tt)
get_path(tt)
----------------------------这个要多抄一些.
import os
def gv_fun(fun):
    def wrapper(*args,**kwargs):
        gg = fun(*args,**kwargs)
        next(gg)
        return gg
    return wrapper
@gv_fun
def pp():
    while True:
        abs_path=yield
        print(abs_path)
def get_path(pp):
    g=os.walk(r'D:\PycharmProjects\wadsd\day4')
    for base_apth,_,files in g:
        abs_path='%s\%s' %(base_apth,files)
        pp.send(abs_path)
get_path(pp())
 
------------------------------------------------------
import os
def wrapper(fun):
    def inner(*args,**kwargs):
        gg=fun(*args,**kwargs)
        next(gg)
        return gg    #最后要返回 生成器
    return inner
def get_path(pt):  #这个是最后执行的方法  #这里获取了生成器为了下一步的send发送信息
    g_p=os.walk(r'D:\PycharmProjects\wadsd\day4')
    for base_dir,_,files in g_p:
        abs_path='%s\%s' %(base_dir,files)
        pt.send(abs_path)
#装饰器是装饰生成器,应为生成器每次生成器每次生成之后都需要做一次next操作,
# 装饰器是装饰一个对象每次方法前或者方法后执行的内容
@wrapper
def pt():
    while True:
        abs_p=yield
        print(abs_p)
 
get_path(pt())

第七节:三元表达式 列表推导式  生成器表达式.

第七节:三元表达式 列表推导式  生成器表达式.
 
1.三元表达式
# def my_max(x,y):
#     if x>y:
#         print(x)
#         return(x)
#     else:
#
#         return y
#
# print(my_max(10,20))
 
x=10
y=5
tt=x if x > y else y
 
print(tt)
 
a=111
b=222
 
pp=a if a>b else b
print(pp)
 
name=input("ttt:")
 
res='SB' if name=='alex' else 'NB'
print(res)
 
2.列表推导式
生成一个列表
l= []
 
for i in range(1,11):
    # print(i)
    res='egg%s'%(str(i))
    l.append(res)
 
print(l)
 
tt=['egg%s'%(str(i)) for i in range(1,10)]
 
print(tt)
 
['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']
pp=[str(i) for i in 'hello']
 
print(pp)
 
---列表推导式衍生版本,后面加条件
tt=[str(i) for i in range(10) if i>6 and i<10]
 
print(tt)
 
3.生成器表达式,将列表表达式的[]中括号改为()小括号
 
tt=['egg%s'%(str(i)) for i in range(5,1000) if i>500 and i<600]
 
print(tt)
 
tt2=('egg%s'%(str(i)) for i in range(5,1000) if i>500 and i<600)
print(tt2)
print(next(tt2))
#列表表达式生成的是一个生成器.
<generator object <genexpr> at 0x031554E0>
egg501
 
#生成器表达式的优点是一次生成一个值在内存.

第八节声明式编程.

第八节声明式编程.
 
# 将names=['egon','alex_sb','wupeiqi','yuanhao']中的名字全部变大写)
names=['egon','alex_sb','wupeiqi','yuanhao']
NM=[i.upper() for i in names]
print(NM)
 
# 将names=['egon','alex_sb','wupeiqi','yuanhao']中以sb结尾的名字过滤掉，然后保存剩下的名字长度
names=['egon','alex_sb','wupeiqi','yuanhao']
nn=[i for i in names if not i.endswith('sb')]
 
print(nn)
 
# 求文件a.txt中最长的行的长度（长度按字符个数算，需要使用max函数）
l=[]
with open(r'tt2.txt','r',encoding='utf-8') as f:
    tt=[len(line) for line in f] # (len(line) for line in f) 写一个生成器比列表更好
    print(tt)
    print(max(tt)
 
# 4、求文件a.txt中总共包含的字符个数？思考为何在第一次之后的n次sum求和得到的结果为0？（需要使用sum函数）
with open('tt2.txt', encoding='utf-8') as f:
    print(sum(len(line) for line in f))
 
# tesla,1000000,10
# chicken,200,1
#
# 求总共花了多少钱？
#
# 打印出所有商品的信息，格式为[{'name':'xxx','price':333,'count':3},...]
#
# 求单价大于10000的商品信息,格式同上
 
with open('tt2.txt','r',encoding='utf-8') as f:
 
    info_name=[ 'name:%s'%(line.split(',')[0])    for line in f]
    print(info_name)
 
with open('tt2.txt','r',encoding='utf-8') as f:
    info_sum=['sum:%s'%(int(line.split(',')[1])*int(line.split(',')[2])) for line in f]
    print(info_sum)
 
tt=(i for i in range(10))
print(max(tt))
# print(max(tt))
 
上面第二行报错的原因是获取的g是一个生成器,max相当于迭代器,第一次迭代后无法做二次迭代相当于for循环.
 
with open('tt2.txt','r',encoding='utf-8') as f:
    print(max((len(i) for i in f)))

第九节递归调用.

#递归调用在调用一个函数的时候直接或者间接,调用了自己
 
def fun1(n):
    print("===",n)
    fun1(n+1)
 
fun1(1)
#python最大调用层数10000
=== 997
=== 998Traceback (most recent call last):
 
import sys
 
print(sys.getrecursionlimit())
#
1000