python自动化开发-[第五天]-面向过程、模块、包

时间：2017-06-03 10:02:16 阅读：168 评论：0 收藏：0 [点我收藏+]

标签：turn os.walk usr and 能力进程递归 bin 开发

今日概要：

　　1、内置模块

　　2、协程函数

　　3、递归

　　4、面向过程编程与函数编程

　　5、模块

　　6、包

　　7、re正则

一、内置模块

　　1、匿名函数lambda

　　定义：匿名函数通常是创建了可以被调用的函数，它返回了函数，而并没有将这个函数命名

#不使用匿名函数
def func(x,y):
    return x+y

func(1,2)


#使用匿名函数
f=lambda x,y:x+y
print(f(1,2))

　　2、max,zip(拉链函数),sorted用法

age={
‘dragon‘:18,
‘panda‘:20,
‘banana‘:21,
‘lili‘:30
}

print(max(age))

#默认是以字典的key进行排序，key如果是字符串就按照首位顺序，首位如果一致，一次递归比较
#方法一，用zip将key和values反转
res=zip(age.values(),age.keys())

print(max(res))

def foo(k):
    return age[k]

print(max(age,key=foo))
print(max(age,key=lambda k:age[k]))
print(min(age,key=lambda k:age[k]))

print(sorted(age)) #默认的排序结果是从小到大
print(sorted(age,key=lambda x:age[x])) #默认的排序结果是从小到大
print(sorted(age,key=lambda x:age[x],reverse=True)) #默认的排序结果是从小到大，resverse反转从大到小

　　3、map,reduce,filter

　　　　1、map

#map,将lambda函数对应的关系映射到列表里
l=[‘dragon‘,‘banana‘,‘water‘]
res=map(lambda x:x+‘_guess‘,l)
print(res)  #返回值为迭代器
print (list(res))

　　　 2、reduce

#1、默认不加参数，从列表中取出一个值当作元素，然后依次取出第二个值到最后依次与第一个元素做运算，最终得出最后的值
#2、加参数后就从参数中取第一个值
from functools import reduce

l=[1,2,3,4,5]
print(reduce(lambda x,y:x+y,l,10))

　　　　3、filter

#filter过滤规则，将匹配的元素提取出来
l=[‘test123‘,‘goto123‘,‘run123‘,‘pass‘]

res=filter(lambda x:x.endswith(‘123‘),l)
print(list(res))

二、协程函数

　　python由于GIL的原因，导致其线程无法发挥多核的并行计算能力（后来有了multiprocessing，可以实现多进程并行），显得比较鸡肋。既然在GIL之下，同一时刻只能有一个线程在运行，那么对于CPU密集的程序来说，线程之间的切换开销就成了拖累，而以I/O为瓶颈的程序正是协程所擅长的：多任务并发（非并行），每个任务在合适的时候挂起（发起I/O）和恢复(I/O结束)

#!/usr/bin/python
# -*- coding:utf-8 -*-
#例子：
def f1(func):

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

@f1
def eater(name):
    print (‘%s ready to eat‘ %(name))
    while True:
        food = yield
        print (‘%s,%s‘ %(name,food))

g = eater(‘alex‘)

g.send(‘jjj‘)

三、递归

　　定义：在函数调用过程中，直接或间接地调用了函数本身，这就是函数的递归调用

　　notice:python默认最大递归数为1000，sys.getrecursionlimit()查看

l = list(range(1000))
def to(info,g):
    if len(info) == 0:
        print (‘not exit‘)
        return
    mid = int(len(info)/2)
    if info[mid] > g:
        print (‘%s‘ %(info[0:mid]))
        to(info[0:mid],g)
    elif info[mid] < g:
        print (‘%s‘ %(info[mid+1:]))
        to(info[mid+1:],g)
    elif info[mid] == g:
        print (info[mid])


to(l,25)

四、面向过程

　　定义：面向过程程序设计：是一种流水线式的变成思路，是机械式

　　优点：程序结构清晰，可以把复杂的问题简单化

　　缺点：扩展性差

　　适用场景：

　　　　　　git程序，httpd服务，linux内核

import os

#1、定义一个初始化yield的装饰器
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
#第四步进行grep过滤，如果第一次存在，则跳过该文件，进入下一次文件判断
@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‘路径‘
g=search(opener(cat(grep(printer(),‘python‘))))
print(g)
g.send(x)