python简述函数调用过程_python函数简介

函数的基础概念

函数是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)