第一节装饰器复习和知识储备------------
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=2def 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 getbaidu=outget('http://www.baidu.com')
print(baidu())第三迭代器.===========不依赖于索引取值的方式
一般迭代可以有索引的
l=[1,2,3,4]
i=0
while i < len(l):print(l[i])i+=1print('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,Iteratorprint(isinstance('hello',Iterable))print(isinstance('hello',Iterator))----------------第九生成器.只要定义函数内部出现yield关键字,
#name再调用该函数,将不会立即执行该函数代码,将会得到该结果就是生成器对象.生成器的本质就是迭代器.return只能返回一次值.yield可以返回多次值.def fc():print("111111111")yield 1print("2222")yield 2print("33333333")yield 3g=fc()print(g)
print(next(g))
print(next(g))
##############
<generator object fc at 0x02C944E0>
111111111
1
2222
2yield的功能:
为我们提供了一种自定义迭代器的方式对比return,可以返回多次值,挂起函数的运行状态.一次yield对应一次next多了报错.
def fc():print("111111111")yield 1,2,'yyy'print("2222")yield 2print("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 startstart+=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 lineelse: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 lineelse: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 lineelse: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的另外一种使用方式.主要作用是给闭包函数传送多个值和接收多个值.
---------------------send的作用一个是给yield赋值,一个是往下走.
def eat(name):print('开始了 %s' %name)while True:food=yieldprint('%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 123print('%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 吃了 Nonedef eat(name):list_food=[]print('开始了 %s' %name)while True:food=yield list_foodprint('%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=yieldprint(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 ostt=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=yieldprint(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=yieldprint(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 ggreturn wrapper
@gv_fun
def pp():while True:abs_path=yieldprint(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=yieldprint(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 yprint(tt)a=111
b=222pp=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 sysprint(sys.getrecursionlimit())
#
1000