Python自动化开发课堂笔记【Day05】

表达式形式的yield

yield的语句形式： yield 1
yield的表达式形式： x=yield

x=yield
g.send('1111') #先把1111传给yield，由yield赋值给x,然后再往下执行，直到再次碰到yield，然后把yield后的返回值返回

协程函数示例

def gen(func):
    def wrapper(*args,**kwargs):
        res = func(*args,**kwargs)
        next(res) #相当于next(g)或者g.send(None)
        return res
    return wrapper

@gen
def eater(name):
    print('%s start to eat' % name)
    food_list = []
    while True:
        food = yield food_list|
        food_list.append(food)
        print('%s start to eat %s'% (name,food))

g = eater('Albert') #初始化操作，由装饰函数gen对eater函数进行初始化，传入一个空值
print(g.send('Apple')) #此时函数挂起在红线出，send执行后，将Apple传给yield，并有yield赋值给food，之后再执行append操作，让后返回food_list
print(g.send('Peach'))

模拟 grep -rl 'python' /root 示例

import os

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

@init
def search_dir(target):
    while True:
        search_path = yield #将搜索路径赋值给search_path
        g = os.walk(search_path)#遍历目录下的所有文件夹和子文件夹以及各文件夹下面的文件
        for par_dir, _, files in g: #遍历列表g中所有的父级文件夹目录和文件
            for file in files:#遍历文件夹下所有文件
                file_abs_path = r'%s\%s', (par_dir, file)#形成绝对路径字符串
                target.send(file_abs_path)#将文件绝对路径传值给open_file函数
@init
def open_file(target):
    while True:
        file_abs_path = yield #将文件绝对路径赋值给file_abs_path
        with open(file_abs_path,'r', encoding='urf-8') as f:
            target.send((f,file_abs_path))#将文件内容和绝对路径传值给cat_file函数
@init
def cat_file(target):
    while True:
        f, file_abs_path = yield #将yield中文件内容和绝对路径赋值
        for line in f:#逐行遍历文件内容
            tag = target.send(line, file_abs_path)#将每行内容和绝对路径传值给grep_line函数进行判断，并返回值tag
            if tag: #如果返回值tag为True,就停止对该文件剩余行数的遍历，并进行下一文件逐行遍历
                break

@init
def grep_line(target,pattern):
    tag = False
    while True:
        line, file_abs_path = yield tag #将每行内容和绝对路径赋值，并取到返回值tag
        tag = False #初始化tag
        if pattern in line:#如果改行内容匹配到目标字符串，返回值tag为True
            tag = True
            target.send(file_abs_path)  #将文件绝对路径传值给print函数打印
@init
def print_file():
    file_abs_path = yield
    print(file_abs_path)

x = r'C:UsersAdministratorPycharmProjectspython17期day5a'
g = search_dir(open_file(cat_file(grep_line(print_file(), 'python'))))
print(g)
g.send(x)

面向过程的程序设计：是一种流水线式的编程思路，是机械式
　　优点：
　　　　程序的结构清晰，可以把复杂的问题简单
　　缺点：
　　　　扩展性差
　　应用场景：
　　　　linux内核，git，httpd

匿名函数 

匿名函数：用之则弃的函数，基本不会占用内存，不像正常的全局函数，会存活到程序结束

def func(x,y):
    return x+y
func(1,2)

f=lambda x,y:x+y
print(f)
print(f(1,2))

内置函数补充

　　1. max,min,zip,sorted的用法, 运用到匿名函数的概念

salaries={
'egon':3000,
'alex':100000000,
'wupeiqi':10000,
'yuanhao':2000
}
for i in salaries:
    print(i)
print(max(salaries))
res=zip(salaries.values(),salaries.keys())

print(list(res))
print(max(res))

def func(k):
    return salaries[k]

print(max(salaries,key=func))
print(max(salaries,key=lambda k:salaries[k]))
print(min(salaries,key=lambda k:salaries[k]))

print(sorted(salaries)) #默认的排序结果是从小到到
print(sorted(salaries,key=lambda x:salaries[x])) #默认的排序结果是从小到到
print(sorted(salaries,key=lambda x:salaries[x],reverse=True)) #默认的排序结果是从小到到

2. map,reduce,filter函数

l=['alex','wupeiqi','yuanhao']
res=map(lambda x:x+'_SB',l)
print(res)
print(list(res))

nums=(2,4,9,10)
res1=map(lambda x:x**2,nums)
print(list(res1))

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

l=['alex_SB','wupeiqi_SB','yuanhao_SB','egon']
res=filter(lambda x:x.endswith('SB'),l)
print(list(res))

递归调用

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

2. 递归效率低，需要在进入下一次递归时保留当前的状态，解决方法是尾递归，但是Python没有，且对递归层级做了限制
　　1.必须有一个明确的结束条件
　　2.每次进入更深一层递归时，问题规模相比上次递归都应有所减少
　　3.递归效率不高，递归层次过多会导致栈溢出。

import sys
print(sys.getrecursionlimit()) #查看Python可以递归的层数，默认1000，可设置
print(sys.setrecursionlimit(1000000)) #设置Pyth可递归层数。最高8000
print(sys.getrecursionlimit()) #查看设置结果

　　3. 递归的原理

age(5)=age(4)+2
age(4)=age(3)+2
age(3)=age(2)+2
age(2)=age(1)+2
age(1)=18

age(n)=age(n-1)+2 #n>2
age(n)=18         #n=1 

def age(n):
    if n == 1:
        return 18
    return age(n-1)+2
print(age(5))

　　4. 递归的应用（二分法）

第一种方式：
raw_lst = [1,5,324,12,67,34,32,879,65,23,4,78,56,2,6,8]
while True:
    lst = sorted(raw_lst)
    t_num = input('>>>: ')
    n = int(t_num)
    while True:
        if len(lst) // 2 == 0:
            print('Nothing found')
            break
        elif lst[len(lst) // 2] == n:
            print('Bingo')
            break
        elif lst[len(lst) // 2] > n:
            lst = lst[:len(lst) // 2]
        elif lst[len(lst) // 2] < n:
            lst = lst[len(lst) // 2:]

第二种方式：
raw_list = [1, 2, 10,33,53,71,73,75,77,85,101,201,202,999,11111]
def search_num(target_num, seq):
    seq = sorted(seq) # 如果列表是无序的情况下需要先进性排序
    if len(seq) == 0:
        return 'Not found...'
    mid_index = len(seq)//2
    mid_num = seq[mid_index]
    if mid_num > target_num:
        seq = seq[:mid_index]
        search_num(target_num, seq)
    elif mid_num < target_num:
        seq = seq[mid_index+1:]
        search_num(target_num, seq)
    elif mid_num == target_num:
        print('Bingo!!!')
search_num(33,raw_list)

模块

1. 什么是模块
　　一个模块就是一个包含了python定义和声明的文件，文件名就是模块名字加上.py的后缀
2. 为什么要使用模块
　　程序中定义的函数或者变量都会因为python解释器的关闭而丢失，因此通常我们会将程序以文件的方式保存下来方便重复利用。
　　为了方便管理越来越多的文件，我们将这些文件归纳为模块，实用的时候就把模块导入到程序中
3. 如何使用模块

# spam模块文件
# -*- coding:utf-8 -*-
# !/usr/bin/python
__all__ = ['money','read1'] #from spam import * 导入的所有变量，类表中只添加所需变量
money = 1000
def read1():
    print('spam->read1->money',money)
def read2():
    print('spam->read2 calling read1')
    read1()
def change():
    global money
    money = 0
#spam.py当作脚本执行时，__name__=='__main__'
#spam.py当作模块导入时，__name__=='模块名'
# print('当前文件的用途是：', __name__)
#作用：用于判断当前文件时按照脚本执行还是模块执行
if __name__ == '__main__':
    print('from the spam.py')
    print('当作脚本执行')
    change()
    print(money)

import...导入模块进行的操作：
1. 产生新的名称空间
2. 以新建的名称空间为全局名称空间，执行文件的代码
3. 拿到一个模块名spam，指向spam.py产生的名称空间
    
# fortest.py文件
# -*- coding:utf-8 -*-
# !/usr/bin/python
import spam as x #起一个别名作为引用
import spam
money = 2000 #此money并非spam名称空间中的money
print(spam.money) #从spam的名称空间中的money变量值
print(x.money) #相同效果
spam.read1()
spam.read2()
spam.change() #修改spam空间中的money变量，任然以spam名称空间定义的为准
print(spam.money)

from...import...导入模块进行的操作:
1. 产生新的名称空间
2. 以新建的名称空间为全局名称空间，执行文件的代码
3. 直接拿到就是spam.py产生的名称空间的名字

优点：方便，不用加前缀
缺点: 容易跟当前文件的名称空间冲突

from spam import * #将spam中所有内容导入，使用时不用加前缀，慎用，容易和当前名称空间中变量发生冲突
可以在模块文件中使用__all__=[]的方法来加以控制所需导入的名称

# fortest.py文件
# -*- coding:utf-8 -*-
# !/usr/bin/python
from spam import read1,money,read2,change
print(money)
read1()
money = 10 #从spam取到的money的值已经被重新绑定赋值，但是spam中的money值没有改变
print(money)
def read1():
    print('===> from fortest.py read1')
read1() #使用当前名称空间中函数定义的功能
read2() #与导入方式无关，此函数从哪个名称空间导入，就会任然沿用该空间函数功能，所以调用的仍然是spam中的read1函数

模块搜索路径

顺序：内存空间 -> 内置函数 -> sys.path（从当前路径开始查找）
import sys
print(sys.path) #查看系统路径
如果需要添加的模块和当前文件不在同一个目录中，那么需要将模块的路径添加到sys.path中，才能添加成功
或者将该模块文件添加到site-package文件夹中

re模块

　　re.match：尝试从字符串的开始匹配一个模式，如：下面的例子匹配第一个单词。 

re.match的函数原型为：re.match(pattern, string, flags)

第一个参数是正则表达式，这里为"(w+)s"，如果匹配成功，则返回一个Match，否则返回一个None；

第二个参数表示要匹配的字符串；

第三个参数是标致位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。

import re
text = "JGood is a handsome boy, he is cool, clever, and so on..."
m = re.match(r"(w+)s", text)
if m:
print m.group(0), '
', m.group(1)
else:
print 'not match'  

　　re.search：会在字符串内查找模式匹配,只到找到第一个匹配然后返回，如果字符串没有匹配，则返回None。

re.search的函数原型为： re.search(pattern, string, flags)

每个参数的含意与re.match一样。 

re.match与re.search的区别：re.match只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，函数返回None；而re.search匹配整个字符串，直到找到一个匹配。

import re
text = "JGood is a handsome boy, he is cool, clever, and so on..."
m = re.search(r'shan(ds)omes', text)
if m:
print m.group(0), m.group(1)
else:
print 'not search'  

re.sub： 用于替换字符串中的匹配项。下面一个例子将字符串中的空格 ' ' 替换成 '-' :  

 re.sub的函数原型为：re.sub(pattern, repl, string, count)

其中第二个函数是替换后的字符串；本例中为'-'

第四个参数指替换个数。默认为0，表示每个匹配项都替换。

re.sub还允许使用函数对匹配项的替换进行复杂的处理。如：re.sub(r's', lambda m: '[' + m.group(0) + ']', text, 0)；将字符串中的空格' '替换为'[ ]'。

import re
text = "JGood is a handsome boy, he is cool, clever, and so on..."
print re.sub(r's+', '-', text) 

re.split： 可以使用re.split来分割字符串，如：re.split(r's+', text)；将字符串按空格分割成一个单词列表。

re.findall： 可以获取字符串中所有匹配的字符串。如：re.findall(r'w*oow*', text)；获取字符串中，包含'oo'的所有单词。

re.compile： 把正则表达式编译成一个正则表达式对象。可以把那些经常使用的正则表达式编译成正则表达式对象，这样可提高一定的效率。下面是一个正则表达式对象的一个例子：

import re
text = "JGood is a handsome boy, he is cool, clever, and so on..."
regex = re.compile(r'w*oow*')
print regex.findall(text)   #查找所有包含'oo'的单词
print regex.sub(lambda m: '[' + m.group(0) + ']', text) #将字符串中含有'oo'的单词用[]括起来。

包

从目录级别来组织模块的，也是通过import引入
　　1. 无论是import形式还是from...import形式，凡是在导入语句中（而不是在使用时）遇到带点的，都要第一时间提高警觉：这是关于包才有的导入语法。
　　2. 包是目录级的（文件夹级），文件夹是用来组成py文件（包的本质就是一个包含__init__.py文件的目录）
　　3. import导入文件时，产生名称空间中的名字来源于文件，import包，产生的名称空间的名字同样来源于文件，即包下的__init__.py,导入包本质就是在导入该文件
注意事项：
　　1. 关于包相关的导入语句也分为import和from ... import ...两种，但是无论哪种，无论在什么位置，在导入时都必须遵循一个原则：
    　　凡是在导入时带点的，点的左边都必须是一个包，否则非法。可以带有一连串的点，如item.subitem.subsubitem,但都必须遵循这个原则。
　　2. 对于导入后，在使用时就没有这种限制了，点的左边可以是包,模块，函数，类(它们都可以用点的方式调用自己的属性)。
　　3. .对比import item 和from item import name的应用场景：如果我们想直接使用name那必须使用后者。