java函数嵌套与闭包_一文搞懂Python函数（匿名函数、嵌套函数、闭包、装饰器）！...

Python函数定义、匿名函数、嵌套函数、闭包、装饰器

函数核心理解

函数也是对象，可以把函数赋予变量

可以把函数当作参数，传入另一个函数中

可以在函数里定义函数，函数嵌套

函数的返回值也可以是函数对象，闭包

1. 函数定义

def name(param1, param2, ..., paramN):

statements

return/yield value # optional

def是可执行语句，函数直到被调用前，都是不存在的，当程序调用函数时，def语句才会创建一个新的函数对象，并赋予其名字

主程序调用函数时，必须保证这个函数此前已经定义过，不然会报错

在函数内部调用其他函数时，函数间哪个申明在前、哪个在后无所谓，只要保证调用时，所需的函数都已经声明定义

python不用考虑输入的数据类型，而是将其交给具体的代码去判断执行，这种行为称为多态。

python函数的参数可以设定默认值，可以指定数据类型 def name(param1 = 0, param2: int, ..., paramN):

函数作用

减少代码的重复性

模块化代码

2. 嵌套函数

2.1 作用

能够保证内部函数的隐私，内部的函数只能被外部函数所调用和访问，不会暴露在全局作用域

合理使用，可以提高程序的运行效率

2.2 函数变量作用域

局部变量：函数内部定义的，只在函数内部有效，一旦执行完毕，局部变量就会被回收，无法访问

全局变量定义在整个层次上的，不能在函数内部随意修改全局变量的值，如要修改，加global关键字

函数内部，局部变量和全局变量同名，局部变量会覆盖全局变量

嵌套函数，内部函数可以访问外部函数定义的变量，但无法修改，如要修改，加nonlocal关键字

内部函数的变量和外部函数变量同名，覆盖

MIN = 1 # 全局变量

MAX = 8

print(f"MIN={MIN},MAX={MAX}")

def f1():

global MIN # 使用global关键字 修改全局变量

MIN += 1

a = 5 # 局部变量

b = 1

print(f"MIN={MIN},a={a},b={b}")

def f2():

MAX = 9 # 局部变量与全局变量同名，局部变量会覆盖全局变量

nonlocal a # 使用nonlocal关键字 修改外部函数的变量

a += 1

b = 2 # 内部函数变量与外部函数变量同名，覆盖

print(f"MIN={MIN},MAX={MAX},a={a},b={b}")

f2() # 内部函数被外部函数调用

f1()

print(f"MIN={MIN},MAX={MAX}")

MIN=1,MAX=8

MIN=2,a=5,b=1

MIN=2,MAX=9,a=6,b=2

MIN=2,MAX=8

3. 闭包

3.1 特点

和嵌套函数类似，只是，外部函数返回的是一个函数，而不是一个具体的值

返回的函数通常赋予一个变量，这个变量可以在后面被继续执行调用

可以简化程序的复杂度，提高可读性

3.2 实例

# 计算一个数的n次幂

def nth_power(exponent):

def exponent_of(base):

return base **exponent

return exponent_of # 返回一个函数

# 调用函数

square = nth_power(2)

print(square)

print(square(3))

.exponent_of at 0x7f3120911b90>

9

4. 装饰器

4.1 形式和作用

@装饰器函数，等价于，原函数名=装饰器函数(原函数名)

装饰器就是通过装饰器函数，来修改原函数的一些功能，使得原函数不需要修改，也就是扩展了原函数的功能

4.2 装饰器函数写法

# 简单装饰器

def my_decorator(func):

def wrapper():

print('wrapper of decorator')

func()

return wrapper

# 带参数的装饰器

def my_decorator(func):

def wrapper(message):

print('wrapper of decorator')

func(message)

return wrapper

# 通用的带参数的装饰器

def my_decorator(func):

def wrapper(*args, **kwargs):

print('wrapper of decorator')

func(*args, **kwargs)

return wrapper

# 保留原函数的元信息，将原函数的元信息，拷贝到对应的装饰器函数里

import functools

def my_decorator(func):

@functools.wraps(func)

def wrapper(*args, **kwargs):

print('wrapper of decorator')

func(*args, **kwargs)

return wrapper

@my_decorator

def greet(message):

print(message)

greet('hello world')

# 输出

wrapper of decorator

hello world

# 类装饰器，依赖函数__call__()

class Count:

def __init__(self, func):

self.func = func

self.num_calls = 0

def __call__(self, *args, **kwargs):

self.num_calls += 1

print('num of calls is: {}'.format(self.num_calls))

return self.func(*args, **kwargs)

@Count

def example():

print("hello world")

example()

# 输出

num of calls is: 1

hello world

4.3 装饰器用法实例

身份认证、日志记录

测试某些函数的执行时间

import time

import functools

def log_execution_time(func):

@functools.wraps(func)

def wrapper(*args, **kwargs):

start = time.perf_counter()

res = func(*args, **kwargs)

end = time.perf_counter()

print(f"{func.__name__} took {(end - start) * 1000)} ms")

return res

return wrapper

@log_execution_time

def calculate_similarity(items):

...

缓存

python中内置的LRU cache，@lru_cache，会缓存进程中的函数参数和结果，缓存满了之后，会删除访问时间最早的数据

工作中，二次开发，在原来的需求基础上做优化，原逻辑不需要修改的化，只需增加新的业务场景的时候

5. 匿名函数

5.1 格式

lambda argument1, argument2,... argumentN : expression

此表达式返回的是一个函数对象，用法举例

# 计算一个数的平方

square = lambda x: x**2 # 返回一个函数对象

a = square(3) # 调用函数

print(a)

# 9

5.2 使用原则

lambda是一个表达式，不是一个语句，只能写成一行

程序中需要使用一个函数完成一个简单的共嗯那个，并且该函数只调用一次

5.3 使用方式

1.用在列表内部

# 计算列表0-9的数的平方

li = [(lambda x: x*x)(x) for x in range(10)]

print(li)

[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

2.用作某些函数的参数

# 按列表中元组的第1个元素排序

lis = [(1, 20), (3, 0), (9, 10), (2, -1)]

lis.sort(key=lambda x: x[0])

print(lis)

[(1, 20), (2, -1), (3, 0), (9, 10)]

# 对一个字典，根据值进行由高到低的排序

d = {"mike": 10, "luck": 2, "ben": 30}

new_li = sorted(d.items(), key=lambda x: x[1], reverse=True) # 返回的是列表嵌套元组类型

new_d = dict(new_li)

print(d,'\n', new_li, '\n', new_d, sep='')

{'mike': 10, 'luck': 2, 'ben': 30}

[('ben', 30), ('mike', 10), ('luck', 2)]

{'ben': 30, 'mike': 10, 'luck': 2}

3.数据清洗中，常用lambda函数

6. python函数式编程

6.1 概念

指代码中每一块都是不可变的，都由纯函数的形式组成

纯函数，是指函数本身相互独立、互不影响，对于相同的输入，总会有相同的输出

6.2函数式编程的优缺点

优点主要在于其纯函数和不可变的特性使程序更加健壮，易于调试和测试

缺点主要在于限制多，难写

6.3 map()、filter() 和 reduce()函数

map(function, iterable)，对序列中的每个元素都运用function这个函数，返回一个迭代器

# 对列表中的每个元素乘以2

li = [1, 2, 3, 4, 5]

new_list_1 = map(lambda x: x*2, li)

print(list(new_list_1)) # 将迭代器转换为列表

[2, 4, 6, 8, 10]

filter(function, iterable)，对序列中的每个元素，都使用function判断，并返回True或者False,最后将返回True的元素组成一个新的可遍历的集合，返回迭代器类型

# 返回列表中能够整除2的元素

li = [1, 2, 3, 4, 5]

new_list_2 = filter(lambda x: x % 2 == 0, li)

print(list(new_list_2))

[2, 4]

reduce(function, iterable)，规定有两个参数，表示对序列中的每个元素以及上一次调用后的结果，运用function进行计算，最后返回的是一个单独的数值

# 计算列表元素的乘积

from functools import reduce

li = [1, 2, 3, 4, 5]

product = reduce(lambda x, y: x * y, li)

print(product)

120