函数的基础概念
函数是python为了代码最大程度地重用和最小代码冗余而提供的基本数据结构。 函数是一种设计工具,可能将复杂的程序,分解成可以管理的块。
在python中可以创建四种函数:
全局函数:定义在模块中
局部函数:嵌套在其他函数中
lambda函数:表达式
方法:与特定数据类型关联的函数,并且只能与数据类型关联一起使用。
创建函数
语法
def functionName(parameters)
suite
函数的调用形式:
语句形式:
func()
表达式形式:
res = func2(10)
函数当另一个函数的参数传入一个函数调用:
res = func3(func2(10))
函数的作用域:
python创建、改变或者查找变量名都是在名称空间进行
在代码中变量名被赋值的位置决定了其能被访问到的范围
函数定义了本地作用域,而模块定义了全局作用域
每个模块都是一个全局作用域,因此全局作用域仅限单个程序文件。
每次对函数的调用都会创建一个新的本地作用域,赋值的变量除非声明为全局变量,否则均为本地变量。
所有的变量名都可以归纳为本地、全局或者内置的变量。
内置名称空间:python解释器自带的名字,python解释器启动就会生成。
全局名称空间:文件和模块级别定义的名字都会。
局部名称空间:定义在函数内部的名字。局部名称空间只有在函数调用时才会生效,调用结束失效。
变量名解析:LEGB原则,作用域越小优先级越高,某个变量,现在本地函数找,找不到去上一层函数找,再找不到就去模块全局变量找,再找不到就去系统内置的变量找,最后还是内找不到,抛出异常。
LEGB原则:
备注:
global定义全局变量,可以在函数内部改变函数外面定义的全局变量的赋值
locals局部作用域,可以改变函数内变量赋值,无论函数内套多少层函数。
函数的嵌套
语法
函数的嵌套定义
def f1():
def f2():
def f3():
print('from f3')
f3()
f2()
f1()
备注:函数嵌套可以进行多层嵌套
python参数的匹配模型
传递参数的方式:
第一种:通过位置,精确匹配参数个数进行从左至右传递参数。
In [26]: def f1(x,y):
....: print(x,y)
....:
In [27]: f1(1,2)
1 2
第二种:通过关键字明确指定参数
In [26]: def f1(x,y):
....: print(x,y)
....:
In [28]: f1(y=1,x=2)
2 1
混用上面两种方式时:所有位置参数先写,所有的关键字参数可以不按顺序写。
In [29]: def f1(x,y,z):
....: print(x,y,z)
....:
In [30]: f1(1,z=3,y=2)
1 2 3
可以给个默认参数,如果不传递参数,就启用默认参数。
In [32]: def f1(x,y,z=3):
print(x,y,z)
....:
In [33]: f1(1,2)
1 2 3
可变参数:
定义的时候*可以收集多个位置参数,表现形式是元组
In [34]: def f2(*x):
....: print(x)
....:
In [35]: f2(1,2,3)
(1, 2, 3)
**可以收集多个关键字参数,表现形式是字典。
In [36]: def f2(**x):
print(x)
....:
In [37]: f2(x=1,y=2,z=3)
{'x': 1, 'y': 2, 'z': 3}
闭包函数
内部函数包含对外部作用域而非全局作用域的引用
闭包函数的特点:
自带作用域
延迟计算
闭包的意义:返回的函数对象,不仅仅是一个函数对象,在该函数外还包裹了一层作用域,这使得,该函数无论在何处调用,优先使用自己外层包裹的作用域
例子:编写下载网页内容的函数,要求功能是:用户传入一个url,函数返回下载页面的结果
from urllib.request import urlopen
def index(url):
def get():
return urlopen(url).read()
return get
pa360 = index('https://hao.360.cn/?src=bm')
print(pa360())
函数装饰器
装饰器本身是一个函数,用于装饰其它函数
增强被装饰函数的功能。
装饰器一般接受一个函数作为参数,以对其进行增强。
语法: 被装饰函数的正上方使用@装修器名称,单独一行。
@deco1
def func1():
pass
例子:编写装饰器,为函数加上统计时间的功能
import time
import random
from functools import wraps
def time1(func):
def time2():
'time2'
start_time = time.time()
func()
stop_time =time.time()
print('run time is %s'%(stop_time-start_time))
return time2
@time1
def func1():
'func1'
time.sleep(random.randrange(1,5))
print('welecome to func1')
例子:编写装饰器,为多个函数加上认证的功能(用户的账号密码来源于文件),要求登录成功一次,后续的函数都无需再输入用户名和密码 # 注意:从文件中读出字符串形式的字典,可以用eval('{"name":"egon","password":"123"}')转成字典格式
user_d1 = {
'gangdan':'123',
'laowang':'123',
'xiaoming':'123'
}
with open('db.txt','w',encoding='utf-8') as f:
f.write(str(user_d1))
login_d1 = {'user':None,'status':False }
db_path =r'db.txt'
def fauth(func):
def auth(*args,**kwargs):
if login_d1['user'] and login_d1['status']: #这个地方如果没有登录成功None第一行就执行不成功。
res = func(*args,**kwargs)
return res
user = input('input user :')
passwd = input('input passwd :')
with open(db_path, 'r', encoding='utf-8') as f:
user_d2 = eval(f.read())
if user in user_d2 and passwd == user_d2[user]:
print('login ok')
login_d1['user'] = user
login_d1['status'] = True
res = func(*args,**kwargs)
return res
else:
print('login error')
return auth
@fauth
def fucn1():
print('welecome to func1')
@fauth
def func2(name):
print('welecome to func2')
fucn1()
func2('gangdan')
例子:编写装饰器,实现缓存网页内容的功能:
from urllib.request import urlopen
import os
file_path = r'url.txt'
def cache(func):
def wrapper(*args,**kwargs):
if os.path.getsize(file_path):
with open(file_path,'rb') as f:
res = f.read()
print('从缓存文件下载')
else:
res = func(*args,**kwargs)()
with open(file_path,'wb') as f:
f.write(res)
print('从网站下载')
return res
return wrapper
@cache
def url1(url):
def get(*args,**kwargs):
return urlopen(url).read()
return get
print('第一下载')
print(url1('https://www.baidu.com/'))
print('第二下载')
print(url1('https://www.baidu.com/'))
print('第三下载')
print(url1('https://www.baidu.com/'))
例子:还记得我们用函数对象的概念,制作一个函数字典的操作吗,来来来,我们有更高大上的做法,
# 在文件开头声明一个空字典,然后在每个函数前加上装饰器,完成自动添加到字典的操作
func_dic = { }
def deco (key):
def deco2(func):
func_dic[key] = func
return deco2
@deco('f1') # f1= deco2(f1) dec2(f1)执行后就是把'f1':'f1函数内存地址加进字典'
def f1():
print('from f1')
@deco('f2') # f2= deco2(f2) dec2(f2)执行后就是把'f2':'f2函数内存地址加进字典'
def f2():
print('from f2')
@deco('f3') # f3= deco2(f3) dec2(f3)执行后就是把'f3':'f3函数内存地址加进字典'
def f3():
print('from f3')
print(func_dic)
while True:
cmd = input('>>: ').strip()
if cmd == 'q':
break
if cmd in func_dic:
func_dic[cmd]()
生成器
生成器函数:常规函数定义,但是,使用yield语句而不是return语句返回结果。yield语句一次返回一个结果,在每个结果中间,挂起函数的状态,以便下次重它离开的地方继续执行
生成器函数优点:
1.是可迭代对象
2.生成器本质和其他的数据类型一样,都是实现了迭代器协议,只不过生成器附加了一个延迟计算省内存的好处。
例子:编写实现tail -f a.txt |grep 'error' |grep '404'命令函数,使用生成器函数。
import time
def tail(file_path,encodimg='utf-8'):
with open(file_path,encoding=encodimg) as f:
f.seek(0,2)
while True:
line = f.readline()
if line:
yield line
else:
time.sleep(0.3)
def grep(lines,pattern):
for line in lines:
if pattern in line:
yield line
g1 = tail('a.txt')
g2 = grep(g1,'error')
g3 = grep(g2,'404')
for i in g3:
print(i)
协程函数
除了可以使用 next()方法来获取下一个生成的值,用户还可以使用 send()方法将一个新的或者是被修改的值返回给生成器。第一个值必须初始化,才能使用send进行传值。
例子:
def init(func): #初始化装饰器
def wrapper(*args,**kwargs):
res = func(*args,**kwargs)
next(res)
return res
return wrapper
@init
def eater(name):
print('%s ready to eat'%name)
food_list = [ ]
while True:
food = yield food_list #使用yield 表达式模式进行传值
food_list.append(food)
print('%s start to eat %s'%(name,food))
g = eater('alex')
print(g.send('饺子'))
面向过程编程
"面向过程编程"(Procedure Oriented)是一种以过程为中心的编程思想,就是分析出解决问题所需要的步骤,然后用函数把这些步骤一步一步实现,使用的时候一个一个依次调用就可以了。整个过程就相当于一条生产的流水线。
例子:运用过程式编程:模拟grep -rl 功能:
import os
def init(func):
def wrapper(*args,**kwargs):
res = func(*args,**kwargs)
next(res)
return res
return wrapper
#阶段一:递归地找文件的绝对路径,把路径发给阶段二
@init
def search(target):
'sear file abspath'
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):
'get file obj: f = open(filepath)'
while True:
file_path = yield
with open(file_path,encoding='utf-8') as f:
target.send((file_path,f))
# 阶段三:收到文件对象,for循坏读取文件的每一行内容,把每一行内容发给阶段四。
@init
def cat(target):
'read file'
while True:
filepath ,f = yield
for line in f:
res = target.send((filepath,line))
if res:
break
# 阶段四:收到一行内容,判断root是否在一行中,如果在,则把文件名发给阶段五
@init
def grep(target,pattern):
'grep function'
tag = False
while True:
filepath,line = yield tag
tag = False
if pattern in line:
target.send(filepath)
tag = True
#阶段五:收到文件名,打印结果
@init
def printer():
'print function'
while True:
filepath = yield
print(filepath)
start_path = r'E:\py_code\py_s5\py_s5\day11\a'
g = search(opener(cat(grep(printer(),'root'))))
g.send(start_path)