Python之知识点（六）

一、匿名函数

lambda表达式就是一个简单的函数，使用lambda声明的函数可以返回一个值，在调用函数时，直接使用lambda表达式的返回值，使用lambda声明函数的语法格式如下：

lambda  arg1,arg2,arg3...:(表达式）

其中arg1/arg2/arg3为函数的参数，（表达式）相当于函数体。运算结果为：表达式的运算结果。

匿名函数有个限制，就是只能有一个表达式，不用写return，返回值就是该表达式的运算结果 。

用匿名函数的好处，因为函数没有名字，不必担心函数名冲突。此外，匿名函数也是一个函数对象，也可以把匿名函数赋值给一个变量，再利用变量来调用该函数。

【示例】lambda使用

#lambda arg1,arg2.arg3.......:表达式
f=lambda a,b,c:a+b+c
print('调用：',f(3,4,5))

#匿名函数作为map高阶函数的参数   f(x)=x*x
L=map(lambda x:x*x,[1,2,3,4,5,6,7,8,9])
print(list(L))

#sorted中使用匿名函数
class Student:
    def __init__(self,name,age):
        self.name=name
        self.age=age

stu1=Student('张三',21)
stu2=Student('李四',27)
stu3=Student('王五',25)
result_list=sorted([stu1,stu2,stu3],key=lambda x:x.age)
for stu in result_list:
    print('name:',stu.name,'age:',stu.age)
result_list=sorted([stu1,stu2,stu3],key=lambda x:x.name)
for stu in result_list:
    print('name:',stu.name,'age:',stu.age)

二、闭包

在Python中，闭包意味着要有嵌套定义，内部函数使用外部函数中定义的变量，如果一个函数A，这个函数A返回一个函数B，这个返回的函数B就叫做闭包。

【示例】闭包的使用

#使用闭包，完成求两个数的和
def sum(a,b):
    return a+b

def funOut(num1):
    def funIn(num2):
        nonlocal num1
        num1+=100
        return num1+num2
    return funIn

f=funOut(100)     #调用外部函数，用f变量指向内部函数
print(type(f))
result=f(200)     #通过变量调用函数
print('两个数的和：',result)

funIn=funOut(100)
print(type(funIn))
result=funIn(200)
print('两个数的和：',result)

【示例】使用闭包求两点之间的距离

#使用闭包求两个点之间的距离
import math
def getDis(x1,y1,x2,y2):
    return math.sqrt((x1-x2)**2+(y1-y2)**2)
#求点(1,1)距离原点的距离
result=getDis(1,1,0,0)
print('两点距离：',result)

#使用闭包求两点之间的距离
def getDisOut(x1,y1):
    def getDisIn(x2,y2):
        return math.sqrt((x1-x2)**2+(y1-y2)**2)
    return getDisIn

#求点(1,1)距离原点的距离
#调用外部函数
getDisIn=getDisOut(0,0)
result=getDisIn(1,1)
print('两点距离：',result)

闭包的特殊用途，可以在不修改源代码的前提下，添加新的功能。

【示例】添加日志信息

#闭包的特殊用途：不修改源代码的前提下，添加新的功能
#添加日志输出信息
import time


def writeLog():
    try:
        file=open('writeLog.txt','a',encoding='utf-8')
        #向文件中写入日志信息（访问：方法名   时间）
        file.write('访问:')
        file.write(func.__name__)
        file.write('\t')
        file.write('时间：')
        file.write(time.asctime())
        file.write('\n')
    except Exception as e:
        print(e.args)
    finally:
        file.close()
def fun1():
    writeLog(fun1)
    print('功能1')
def fun2():
    writeLog(fun2)
    print('功能2')

#使用闭包，不修改fun1  和fun2的功能代码，添加日志信息
def funcOut(func):
    def funcIn():
        writeLog(func)
        func()
    return funcIn

fun1=funcOut(fun1)
fun1()

三、装饰器

在Python中，装饰器就是一种闭包，它可以使闭包的访问方式更简单。

【示例】装饰器的基本使用

#使用装饰器 完成不修改fun1()  fun2()函数的源码，添加输出日志信息
import time

def writeLog():
    try:
        file=open('log.txt','a',encoding='utf-8')
        file.write('访问：')
        file.write(func.__name__)
        file.write('\t')
        file.write('时间：')
        file.write(time.asctime())
        file.write('\n')
    except Exception as e:
        print(e.args)
    finally:
        file.close()

#使用闭包
def funcOut(func):
    def funcIn():
        writeLog(func)
        func()
    return funcIn
#闭包的调用
@funcOut  #fun1=funcOut(fun1)
def fun1():
    print('功能1')
def fun2():
    print('功能2')
fun1()

【示例】多个装饰器的使用

#给foo函数，新增功能
#调用foo函数前，输出'i am foo'
def funOut(func):
    print('装饰器1')
    def funIn():
        print('I am foo')
        func()
    return funIn
def funOut2(func):
    print('装饰器2')
    def funIn():
        print('hello')
        func()
        return funIn

@funOut2
@funOut
def foo():
    print('foo函数正在运行')

#使用闭包调用
foo()

【示例】带参数的装饰器

import time
def fun1():
    print('功能1')

def foo():
    print('foo函数正在运行')

def writeLog(func):
    print('访问了方法名：',func.__name__,'\t时间：',time.asctime())

def funOut(func):
    def funIn(x,y):
        writeLog(func)
        return func(x,y)
    return funIn

@funOut
def sum(a,b):
    return a+b

result=sum(10,20)
print('两个数和：',result)

#功能函数三个参数
def funOut2(func):
    def funcIn(a,b,c):
        writeLog(func)
        return func(a,b,c)
    return funcIn
@funOut2
def add(a,b,c):
    return a+b+c

result=add(10,20,30)
print('三个数的和：',result)