python学习第四天回顾（生成器，内置函数,yield表达式形式）

一、生成器

　　生成器函数：只要函数体包含yield关键字，该函数就是生成器函数

　　生成器就是迭代器

    def foo():　　#此为非生成器的函数示例
        return 1
        return 2
        return 3
        return 4

    res1=foo()
    print(res1)　　#return只能返回函数中的一个值

    返回结果为：
     1　　

    def foo():　　#此为生成器的示例
        print('first')
        yield 1
        print('second')
        yield 2
        print('third')
        yield 3
        print('fourth')
        yield 4
        print('fifth')
　　#包含yield关键字，即为生成器函数
    g=foo()　　#生成器对象foo的内存地址
    for i in g:　　#遍历foo的内存地址的内容
        print(i)　　

    返回结果为：　　#yield一次返回一个值
    first
    1
    second
    2
    third
    3
    fourth
    4
    fifth

    print(g)　　#生成器即迭代器

    print(next(g)) #触发迭代器g的执行，进而触发函数的执行
    print(next(g))
    print(next(g))
    print(next(g))
    print(next(g))

    计数器小程序示例：
    def counter(n):
        print('start...')
        i=0
        while i < n:
            yield i
            i+=1
        print('end...')


    g=counter(5)
    for i in g:
        print(i)

    返回结果为：
    start...
    0
    1
    2
    3
    4
    end...

　　yield的功能：

　　1、相当于为函数封装好__iter__和__next__

　　2、return只能返回一次值，函数就终止了，而

　　yield能返回多次值，每次返回都会将函数暂停，下一次next会从上一次暂停的位置继续执行

　　模仿tail -f a.txt|grep python小程序：

#tail -f a.txt | grep 'python'

    import time　　#导入time函数
    def tail(filepath):　　#定义一下tail函数，设置形参为filepath用于获取文件名
        with open(filepath,encoding='utf-8') as f:　　#打开文件
            f.seek(0,2)　　#将光标定位到最后
            while True:
                line=f.readline().strip()　　#读取文件中的一行，并去除空格
                if line:　　#如果有内容则返回该行
                    yield line
                else:　　#否则等待0.2秒
                    time.sleep(0.2)

    t=tail('a.txt') #以迭代器的形式赋值给t

    for line in t:　　#遍历t得到line的值
        print(line)

    def grep(pattern,lines):　　#定义一下grep函数进行查找（形参为pattern,lines，对应grep（）函数中的实参）
        for line in lines:
            if pattern in line:
                yield line

    g=grep('python',tail('a.txt'))　　#实参对应grep()的形参，将grep函数返回的值给g
    print(g)　　#打印出g的值来

    for i in g:
        print(i)

yield表达式形式

#协程函数

    def deco(func):　　#检测是否被装饰器所调用检测到有@deco，则跳到@deco并获取eater的内存地址，赋值给形参func
        def wrapper(*args,**kwargs):　　#定义wrapper函数，检测是不是闭包函数，执行函数体的内容
            res=func(*args,**kwargs)　　#执行func()函数，即执行eater(name)函数==》eater('alex'),将eater生成器的内存地址传给res
) 4             next(res)　　#next()方法执行生成器，即执行eater()函数，跳转到eater(name)函数体内，首先执行打印语句
            return res　　#由food=yield返回给res，现在food为空，所以不会返回值，执行下一个操作g.send()，send有传值的功能，所以会把里面的内容，传给food
        return wrapper

    @deco
    def eater(name):
        print('%s ready to eat' %name)　　#打印
        food_list=[]　　#food_list赋值为列表
        while True:　　#执行循环
            food=yield food_list #检测到yield,返回到上一层，return res， yield 后面的food_list为返回值将会返回food_list里的内容
            food_list.append(food)　　#执行g.send("猪肉") send有传值功能，将里面的内容传给food并在food_list内做追加，跳转到下一条命令
            print('%s start to eat %s' %(name,food))　　#打印


    g=eater('jack')　　#上面的都是定义的内容，在执行eater("alex")后才是调用
    print(g)
    next(g)

    g.send("猪肉“)　　#send与next一样都会触发函数的从上往下走的功能，并且send还有传值功能
    g.send("牛肉")
    g.send("饼干")
    g.send("馒头")
    print(g)
    print(g.send("猪肉“))　　#执行g.send("猪肉")，然后打印其返回结果
    print(g.send("牛肉"))
    print(g.send("饼干"))
    print(g.send("馒头"))

    返回结果为：
    jack ready to eat
    jack start to eat 猪肉
    jack start to eat 牛肉
    jack start to eat 饼干
    jack start to eat 馒头
    jack start to eat 猪肉
    ['猪肉', '牛肉', '饼干', '馒头', '猪肉']
    jack start to eat 牛肉
    ['猪肉', '牛肉', '饼干', '馒头', '猪肉', '牛肉']
    jack start to eat 饼干
    ['猪肉', '牛肉', '饼干', '馒头', '猪肉', '牛肉', '饼干']
    jack start to eat 馒头
    ['猪肉', '牛肉', '饼干', '馒头', '猪肉', '牛肉', '饼干', '馒头']

#表达式形式的yield的用途

#grep -rl "python" /root   查看root目录下面的文件是否有包含python的内容，有则把文件打印出来

os.walk()方法 用于通过在目录树中游走输出在目录中的文件名，向上或向下。
　　walk()语法：
　　　　os.walk(top,[,topdown=True[,onerror=None[,foolowlinks=False]]])
　　参数：
　　　　top -- 根目录下的每一个文件夹（包含它自己），产生3-元组（dirpath,dirnames,filenames）[文件夹路径，文件夹名字，文件名]
　　　　topdown -- 可选，为True或者没有指定，一个目录的3-元组将比它的任何子文件的3-元组先产生（目录自上而下）。如果topdown为False,一个目录的3-元组将比它的任何子文件夹的3-元组后产生（目录自下而上）
　　　　onerror -- 可选，是一个函数，它调用时有一个参数，一个OSError实例。报告这错误后，继续walk，或抛出exception终止walk
　　　　followlinks -- 设置为true,则通过软连接访问目录

    import os

    def init(func):
        def wrapper(*args,**kwargs):
            res=func(*args,**kwargs)
            next(res)
            return res
        return wrapper

    @init
    def search(target):
        while True:
            search_path=yield
            g=os.walk(search_path)
            for par_dir,_,files in g:
                for file in files:
                    file_abs_path=r'%s\%s' %(par_dir,file)
                    # print(file_abs_path)
                    target.send(file_abs_path)

    @init
    def opener(target):
        while True:
            file_abs_path=yield
           # print('opener func==>',file_abs_path)
            with open(file_abs_path,encoding='utf-8') as f:
                target.send((file_abs_path,f))

    @init
    def cat(target):
        while True:
            file_abs_path,f=yield  #(file_abs_path,f)
            for line in f:
                tag=target.send((file_abs_path,line))
                if tag:
                    break
    @init
    def grep(target,pattern):
        tag=False
        while True:
            file_abs_path,line=yield tag
            tag=False
            if pattern in line:
                tag=True
                target.send(file_abs_path)

    @init
    def printer():
        while True:
            file_abs_path=yield
            print(file_abs_path)



    x=r'F:\python17期\day5\day5\a'



    g=search(opener(cat(grep(printer(),'python'))))
    print(g)

    g.send(x)
    

 

二、内置函数

    print(abs(-1))　　#取绝对值
    print(all([1,2,3]))　　#在可迭代对象中for循环，逐个进行布尔判断，全为真值则为真

    print(all([0,2,3]))　　#在可迭代对象中for循环，逐个进行布尔判断，全为真则为值，0在布尔中认为是假值，

    print(all(''))　　#如果为空则返回真值

    print(any([0,None,'',1])) #有一个为真则为值，1为真，则返回值为真
    print(any([0,None,'']))　　#返回false
    print(any([]))　　#空返回为false

    print(bin(3))　　#转换为二进制
    print(hex(17))　　#转换为十六进制
    print(oct(9))　　#转换为八进制

    def func():　　#判断是否为可调用对象
        pass
    print(callable(func))

     print(chr(68))　　#ASCII转换为字符
     print(ord('D'))　　#字符转换为ASCII

    res=complex(1+2j)　　#complex返回一个复数
    print(res.real)
    print(res.imag)

    # dict    字典
    # int     整形
    # str    字符串   
    # set    集合
    # list    列表

    # l=[]
    # print(dir(l)) #查看一个对象下面的属性 即查看列表l的内置属性或方法

    print(help(l))#显示列表l的内置属性的用法

    print(divmod(1000,30))　　#可求出商与余数，可用于分布功能

    cmd='print("你瞅啥")'　　#eval将字符串的内容取出来，并执行。
    eval(cmd)
    dic="{'a':1,'b':2}"
    d=eval(dic)
    print(type(d),d['a'])

    s={1,2} #s=set({1,2}) 定义可变集合
    # s.add(3)
    # print(s)

    # s=frozenset({1,2}) # 定义不可变集合

　　哈希：

　　　　1、只要校验的内容一致，那hash得到结果永远一样

　　　　2、不可逆

　　　　3、只要采用的哈希算法一样，那无论被校验的内容有多长，hash得到的结果长度都一样

    print(hash("qwerfdsa")
    print(hash("qwerfdsa")

    id()
    x=1
    y=x
    print(id(x),id(y))
    print(x is y)

    pow(x,y[,z]) #计算x的y次方，如果z存在，则在对结果进行取模即pow(x,y)%z
    print(pow(10,2,3)
    返回结果为：
    1

    reversed() 返转函数
    l=["a",4,2,3]
    for i in reversed(l):
        print(i)

    round(x[,n]) #返回浮点数x的四舍五入值，n表示保留的位数
    print(round(3.141542653589127134,4))
    返回结果为：
    3.1415    #保留4位，第5位为2所以舍去

    slice()#切片操作，示例如下：
    l=['a','b','c','d','e']
    print(l[1:4:2])
    s=slice(1,4,2)
    print(l[s])

    vars()  #返回对象object的属性和属性值的字典对象。如果默认不输入参数，就打印当前调用位置的属性和属性值，若有参数，则只打印这个参数相应的属性和属性值
    #vars()等同于locals()

    zip()函数#接受任意多个（包括0和1）序列作为参数，返回一个tulpe列表。
    示例：
    s='helloo'
    l=[1,2,3,4,5]

    z=zip(s,l)
    print(z)
    for i in z:
        print(i)
    #两个序列的函数必须相等，若不相等则只会截取相等的长度

    __import__()函数    导入函数

    import time

    m=__import__('time') #以字符串的形式导入模块

    # m.sleep(3000)