Python自动化开发课堂笔记Day04 - Python基础（函数补充，模块，包）

Posted 2020-09-21

表达式形式的yield

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

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

协程函数示例

 1 def gen(func):
 2     def wrapper(*args,**kwargs):
 3         res = func(*args,**kwargs)
 4         next(res) #相当于next(g)或者g.send(None)
 5         return res
 6     return wrapper
 7 
 8 @gen
 9 def eater(name):
10     print(‘%s start to eat‘ % name)
11     food_list = []
12     while True:
13         food = yield food_list|
14         food_list.append(food)
15         print(‘%s start to eat %s‘% (name,food))
16 
17 g = eater(‘Albert‘) #初始化操作，由装饰函数gen对eater函数进行初始化，传入一个空值
18 print(g.send(‘Apple‘)) #此时函数挂起在红线出，send执行后，将Apple传给yield，并有yield赋值给food，之后再执行append操作，让后返回food_list
19 print(g.send(‘Peach‘))

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

 1 import os
 2 
 3 def init(func):
 4     def wrapper(*args,**kwargs):
 5         res = func(*args,**kwargs)
 6         next(res)
 7         return res
 8     return wrapper
 9 
10 @init
11 def search_dir(target):
12     while True:
13         search_path = yield #将搜索路径赋值给search_path
14         g = os.walk(search_path)#遍历目录下的所有文件夹和子文件夹以及各文件夹下面的文件
15         for par_dir, _, files in g: #遍历列表g中所有的父级文件夹目录和文件
16             for file in files:#遍历文件夹下所有文件
17                 file_abs_path = r‘%s\%s‘, (par_dir, file)#形成绝对路径字符串
18                 target.send(file_abs_path)#将文件绝对路径传值给open_file函数
19 @init
20 def open_file(target):
21     while True:
22         file_abs_path = yield #将文件绝对路径赋值给file_abs_path
23         with open(file_abs_path,‘r‘, encoding=‘urf-8‘) as f:
24             target.send((f,file_abs_path))#将文件内容和绝对路径传值给cat_file函数
25 @init
26 def cat_file(target):
27     while True:
28         f, file_abs_path = yield #将yield中文件内容和绝对路径赋值
29         for line in f:#逐行遍历文件内容
30             tag = target.send(line, file_abs_path)#将每行内容和绝对路径传值给grep_line函数进行判断，并返回值tag
31             if tag: #如果返回值tag为True,就停止对该文件剩余行数的遍历，并进行下一文件逐行遍历
32                 break
33 
34 @init
35 def grep_line(target,pattern):
36     tag = False
37     while True:
38         line, file_abs_path = yield tag #将每行内容和绝对路径赋值，并取到返回值tag
39         tag = False #初始化tag
40         if pattern in line:#如果改行内容匹配到目标字符串，返回值tag为True
41             tag = True
42             target.send(file_abs_path)  #将文件绝对路径传值给print函数打印
43 @init
44 def print_file():
45     file_abs_path = yield
46     print(file_abs_path)
47 
48 x = r‘C:\Users\Administrator\PycharmProjects\python17期\day5\a‘
49 g = search_dir(open_file(cat_file(grep_line(print_file(), ‘python‘))))
50 print(g)
51 g.send(x)

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

匿名函数 

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

1 def func(x,y):
2     return x+y
3 func(1,2)
4 
5 f=lambda x,y:x+y
6 print(f)
7 print(f(1,2))

内置函数补充

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

 1 salaries={
 2 ‘egon‘:3000,
 3 ‘alex‘:100000000,
 4 ‘wupeiqi‘:10000,
 5 ‘yuanhao‘:2000
 6 }
 7 for i in salaries:
 8     print(i)
 9 print(max(salaries))
10 res=zip(salaries.values(),salaries.keys())
11 
12 print(list(res))
13 print(max(res))
14 
15 def func(k):
16     return salaries[k]
17 
18 print(max(salaries,key=func))
19 print(max(salaries,key=lambda k:salaries[k]))
20 print(min(salaries,key=lambda k:salaries[k]))
21 
22 print(sorted(salaries)) #默认的排序结果是从小到到
23 print(sorted(salaries,key=lambda x:salaries[x])) #默认的排序结果是从小到到
24 print(sorted(salaries,key=lambda x:salaries[x],reverse=True)) #默认的排序结果是从小到到

2. map,reduce,filter函数

 1 l=[‘alex‘,‘wupeiqi‘,‘yuanhao‘]
 2 res=map(lambda x:x+‘_SB‘,l)
 3 print(res)
 4 print(list(res))
 5 
 6 nums=(2,4,9,10)
 7 res1=map(lambda x:x**2,nums)
 8 print(list(res1))
 9 
10 from functools import reduce
11 l=[1,2,3,4,5]
12 print(reduce(lambda x,y:x+y,l,10))
13 
14 l=[‘alex_SB‘,‘wupeiqi_SB‘,‘yuanhao_SB‘,‘egon‘]
15 res=filter(lambda x:x.endswith(‘SB‘),l)
16 print(list(res))

递归调用

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

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

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

　　3. 递归的原理

 1 age(5)=age(4)+2
 2 age(4)=age(3)+2
 3 age(3)=age(2)+2
 4 age(2)=age(1)+2
 5 age(1)=18
 6 
 7 age(n)=age(n-1)+2 #n>2
 8 age(n)=18         #n=1 
 9 
10 def age(n):
11     if n == 1:
12         return 18
13     return age(n-1)+2
14 print(age(5))

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

 1 第一种方式：
 2 raw_lst = [1,5,324,12,67,34,32,879,65,23,4,78,56,2,6,8]
 3 while True:
 4     lst = sorted(raw_lst)
 5     t_num = input(‘>>>: ‘)
 6     n = int(t_num)
 7     while True:
 8         if len(lst) // 2 == 0:
 9             print(‘Nothing found‘)
10             break
11         elif lst[len(lst) // 2] == n:
12             print(‘Bingo‘)
13             break
14         elif lst[len(lst) // 2] > n:
15             lst = lst[:len(lst) // 2]
16         elif lst[len(lst) // 2] < n:
17             lst = lst[len(lst) // 2:]
18 
19 第二种方式：
20 raw_list = [1, 2, 10,33,53,71,73,75,77,85,101,201,202,999,11111]
21 def search_num(target_num, seq):
22     seq = sorted(seq) # 如果列表是无序的情况下需要先进性排序
23     if len(seq) == 0:
24         return ‘Not found...‘
25     mid_index = len(seq)//2
26     mid_num = seq[mid_index]
27     if mid_num > target_num:
28         seq = seq[:mid_index]
29         search_num(target_num, seq)
30     elif mid_num < target_num:
31         seq = seq[mid_index+1:]
32         search_num(target_num, seq)
33     elif mid_num == target_num:
34         print(‘Bingo!!!‘)
35 search_num(33,raw_list)

模块

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

 1 # spam模块文件
 2 # -*- coding:utf-8 -*-
 3 # !/usr/bin/python
 4 __all__ = [‘money‘,‘read1‘] #from spam import * 导入的所有变量，类表中只添加所需变量
 5 money = 1000
 6 def read1():
 7     print(‘spam->read1->money‘,money)
 8 def read2():
 9     print(‘spam->read2 calling read1‘)
10     read1()
11 def change():
12     global money
13     money = 0
14 #spam.py当作脚本执行时，__name__==‘__main__‘
15 #spam.py当作模块导入时，__name__==‘模块名‘
16 # print(‘当前文件的用途是：‘, __name__)
17 #作用：用于判断当前文件时按照脚本执行还是模块执行
18 if __name__ == ‘__main__‘:
19     print(‘from the spam.py‘)
20     print(‘当作脚本执行‘)
21     change()
22     print(money)

 1 import...导入模块进行的操作：
 2 1. 产生新的名称空间
 3 2. 以新建的名称空间为全局名称空间，执行文件的代码
 4 3. 拿到一个模块名spam，指向spam.py产生的名称空间
 5     
 6 # fortest.py文件
 7 # -*- coding:utf-8 -*-
 8 # !/usr/bin/python
 9 import spam as x #起一个别名作为引用
10 import spam
11 money = 2000 #此money并非spam名称空间中的money
12 print(spam.money) #从spam的名称空间中的money变量值
13 print(x.money) #相同效果
14 spam.read1()
15 spam.read2()
16 spam.change() #修改spam空间中的money变量，任然以spam名称空间定义的为准
17 print(spam.money)
18 
19 from...import...导入模块进行的操作:
20 1. 产生新的名称空间
21 2. 以新建的名称空间为全局名称空间，执行文件的代码
22 3. 直接拿到就是spam.py产生的名称空间的名字
23 
24 优点：方便，不用加前缀
25 缺点: 容易跟当前文件的名称空间冲突
26 
27 from spam import * #将spam中所有内容导入，使用时不用加前缀，慎用，容易和当前名称空间中变量发生冲突
28 可以在模块文件中使用__all__=[]的方法来加以控制所需导入的名称
29 
30 # fortest.py文件
31 # -*- coding:utf-8 -*-
32 # !/usr/bin/python
33 from spam import read1,money,read2,change
34 print(money)
35 read1()
36 money = 10 #从spam取到的money的值已经被重新绑定赋值，但是spam中的money值没有改变
37 print(money)
38 def read1():
39     print(‘===> from fortest.py read1‘)
40 read1() #使用当前名称空间中函数定义的功能
41 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；

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

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

1 import re
2 text = "JGood is a handsome boy, he is cool, clever, and so on..."
3 m = re.match(r"(\w+)\s", text)
4 if m:
5 print m.group(0), ‘\n‘, m.group(1)
6 else:
7 print ‘not match‘  

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

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

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

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

1 import re
2 text = "JGood is a handsome boy, he is cool, clever, and so on..."
3 m = re.search(r‘\shan(ds)ome\s‘, text)
4 if m:
5 print m.group(0), m.group(1)
6 else:
7 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)；将字符串中的空格‘ ‘替换为‘[ ]‘。

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

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

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

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

1 import re
2 text = "JGood is a handsome boy, he is cool, clever, and so on..."
3 regex = re.compile(r‘\w*oo\w*‘)
4 print regex.findall(text)   #查找所有包含‘oo‘的单词
5 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那必须使用后者。