python--表达式形式的yield、面向过程编程、内置函数

yield的表达式形式

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

@init #foo=init(foo)
def foo():
    print('starting')
    while True:
        x = yield None#return
        print('value ：   ', x)

g = foo() #wrapper()

g.send()
结果：
starting
value ：    

send的效果：
     1：先从为暂停位置的那个yield传一个值，然后yield会把值赋值x
     2：与next的功能一样

def init(func):
    def wrapper(*args, **kwargs):
        g = func(*args, **kwargs)
        next(g)
        return g
    return wrapper
#
@init #foo=init(foo)
def foo():
    print('starting')
    while True:
        x = yield None#return
        print('value ：   ', x)
#
g = foo() #wrapper()

print(g)
next(g)
print('='*)
print(g.send())
print('='*)
print(g.send(None)) #g.send(None)等同于next(g)
结果：
starting
<generator object foo at 0x0000000002144990>
value ：    None
==============================
value ：
None
==============================
value ：    None
None

def init(func):
    def wrapper(*args, **kwargs):
        g = func(*args, **kwargs)
        next(g)
        return g
    return wrapper
@init
def eater(name):
    print('%s ready to eat' % name)
    food_list = []
    while True:
        food = yield food_list#return None
        food_list.append(food)
        print('%s start to eat %s' % (name, food))

e = eater('alex')
print(e.send('狗屎'))
print(e.send('猫屎'))
print(e.send('alex屎'))
结果：
alex ready to eat
alex start to eat 狗屎
['狗屎']
alex start to eat 猫屎
['狗屎', '猫屎']
alex start to eat alex屎
['狗屎', '猫屎', 'alex屎']

def init(func):
    def wrapper(*args, **kwargs):
        g = func(*args, **kwargs)
        next(g)
        return g
    return wrapper
@init
def eater(name):
    print('%s ready to eat' % name)
    food_list = []
    while True:
        food = yield food_list#return None
        food_list.append(food)
        print('%s start to eat %s' % (name, food))

def make_shit(people, n):
    for i in range(n):
        people.send('shit%s' % i)

e = eater('alex')
make_shit(e, )
结果：
alex ready to eat
alex start to eat shit0
alex start to eat shit1
alex start to eat shit2
alex start to eat shit3
alex start to eat shit4

应用：grep -rl 'root' /etc

import os
def init(func):
    def wrapper(*args, **kwargs):
        g = func(*args, **kwargs)
        next(g)
        return g
    return wrapper
#阶段一：递归地找文件的绝对路径，把路径发给阶段二
def search(target,start_path):
    g = os.walk(start_path)
    for par_dir, _, files in g:
        for file in files:
            file_path = r'%s\%s' %(par_dir, file)
            target.send(file_path)
#阶段二：收到文件路径，打开文件获取获取对象，把文件对象发给阶段三
@init
def opener(target):
    while True:
        file_path = yield
        with open(file_path, encoding='utf-8') as f:
            target.send((file_path, f))
#阶段三：收到文件对象，for循环读取文件的每一行内容，把每一行内容发给阶段四
@init
def cat(target):
    while True:
        filepath,f = yield
        for line in f:
            target.send((filepath, line))
#阶段四：收到一行内容，判断root是否在这一行中，如果在，则把文件名发给阶段五
@init
def grep(target, pattern):
    while True:
        filepath,line = yield
        if pattern in line:
            target.send(filepath)
#阶段五：收到文件名，打印结果
@init
def printer():
    while True:
        filename = yield
        print(filename)

start_path = r'C:\Users\Administrator\PycharmProjects\untitled4\a'
search(opener(cat(grep(printer(), 'root'))), start_path)
结果：
C:\Users\Administrator\PycharmProjects\untitled4\a\a.txt
C:\Users\Administrator\PycharmProjects\untitled4\a\b\b2.txt
C:\Users\Administrator\PycharmProjects\untitled4\a\b\c\c.txt

进一步优化版本：

import os
def init(func):
    def wrapper(*args, **kwargs):
        g = func(*args, **kwargs)
        next(g)
        return g
    return wrapper
#阶段一：递归地找文件的绝对路径，把路径发给阶段二
@init
def search(target):
    while True:
        start_path = yield
        g = os.walk(start_path)
        for par_dir,_, files in g:
            for file in files:
                file_path = r'%s\%s' % (par_dir, file)
                target.send(file_path)
#阶段二：收到文件路径，打开文件获取获取对象，把文件对象发给阶段三
@init
def opener(target):
    while True:
        file_path = yield
        with open(file_path, encoding='utf-8') as f:
            target.send((file_path, f))
#阶段三：收到文件对象，for循环读取文件的每一行内容，把每一行内容发给阶段四
@init
def cat(target):
    while True:
        filepath, f = yield
        for line in f:
            res = target.send((filepath, line))
            if res:
                break
#阶段四：收到一行内容，判断root是否在这一行中，如果在，则把文件名发给阶段五
@init
def grep(target,pattern):
    tag = False
    while True:
        filepath, line = yield tag
        tag = False
        if pattern in line:
            target.send(filepath)
            tag = True
#阶段五：收到文件名，打印结果
@init
def printer():
    while True:
        filename = yield
        print(filename)

start_path1 = r'C:\Users\Administrator\PycharmProjects\untitled4\a'
start_path2 = r'C:\Users\Administrator\PycharmProjects\untitled4\a\b'
g = search(opener(cat(grep(printer(), 'root'))))

print(g)
# g.send(start_path1)
g.send(start_path2)
结果：
<generator object search at 0x0000000001E04DB0>
C:\Users\Administrator\PycharmProjects\untitled4\a\b\b2.txt
C:\Users\Administrator\PycharmProjects\untitled4\a\b\c\c.txt
<generator object search at 0x0000000001E97048>

def init(func):
    def wrapper(*args, **kwargs):
        g = func(*args, **kwargs)
        next(g)
        return g
    return wrapper
@init  #func=init(func)
def func():
    tag = False
    while True:
        x = yield tag #g.send('b') #x='b'
        tag = False
        if 'root' in x:
            print(x)
            tag = True
g = func()

print(g.send('a'))
print(g.send('root123'))
print(g.send('b'))
print(g.send('c'))
print(g.send('d'))
print(g.send('e'))
结果：
False
root123
True
False
False
False
False

内置函数

print(abs(-))
print(all([, , , ]))
print(all([, , , ]))
print(all([, , , None]))
print(all([, , , '']))
print(all([]))
结果：

True
False
False
False
True

print(all(i for i in range(, )))
print(any(''))
print(any([, '', {}, (), ]))
结果：
True
False
True

print(bin()) #将十进制数转换为二进制数
print(oct()) #将十进制数转换为八进制
print(hex()) #将十进制数转换为十六进制
结果：
0b11
0o11
0xd

print(bool())
print(bool(None))
print(bool(''))
结果：
False
False
False

print(bytes('sss', encoding='utf-8'))
print('sss'.encode('utf-8'))
结果：
b'sss'
b'sss'

def func():
    pass
print(callable(func))  #查看函数是否可以被调用
结果：
True

print(chr()) #返回对象对应的ASCII字符
print(ord('B')) #与chr相反，返回ASCII字符对应的内容
结果：
B

x = complex(-2j) #complex()是复数函数
print(x.real) #查看实部
print(x.imag) #查看虚部
结果：
1.0
-2.0

面向对象的内置函数：

classmethod

staticmethod

property

setattr

delattr

getattr

hasattr

还有：

• int
• dict
• list
• tuple
• set
• str

import os
#
print(dir(os)) #os.walk

print(help(os))

def func():
    'my function'
    pass

print(help(func))

补充

import time
import random
def init(func):
    def wrapper(*args, **kwargs):
        g = func(*args, **kwargs)
        next(g)
        return g
    return wrapper

def producer(target,count):
    for i in range(count):
        time.sleep(random.randrange(, ))
        x = 'baozi%s' % i
        print('\033[45m 厨师造好的包子: %s\033[0m' % x)
        target.send(x)

@init
def consumer(name):
    while True:
        food = yield
        time.sleep(random.randrange(, ))
        print('\033[46m %s start to eat %s \033[0m' % (name, food))

producer(consumer('alex'), )
结果：
 厨师造好的包子: baozi0
 alex start to eat baozi0
.
.
.
 厨师造好的包子: baozi9
 alex start to eat baozi9 

下面为不用yield的版本：

import time
import random

def producer(count):
    res = []
    for i in range(count):
        res.append('baozi %s' %i)
    return res

def consumer(name,res):
    for i in res:
        print('%s start to eat %s' % (name, i))

consumer('alex',producer())
结果：
alex start to eat baozi
alex start to eat baozi
.
.
.
alex start to eat baozi
alex start to eat baozi 

虽然两者都可以实现，但是用yield的程序是：厨师做好一个包子，alex吃一个包子，而不用yield的版本是：厨师做好十个包子之后alex才吃。单是此程序体现的差别，往大方面考虑，涉及内存问题，显然yield版本比较省内存，所以我们建议使用yield版本。