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)