Python 匿名函数 高阶函数 闭包 装饰器

函数的基本使用

def 函数名(参数):
    ......

函数的参数

# 默认参数的使用  如果传参则使用参数  若没传则使用默认值  =》 缺省参数
# 缺省参数要放在最后
def func(param, param1=dufault，param=default)

# 位置参数
func(value1, value2, value3)

# 关键字参数
func(param=value, param2=value2, param3=value3)

# 位置参数和关键字参数混合使用时，位置参数要放在前面
func(value1, param2=value2, param3=value3)

# 可变参数的使用
# *args接收多余的位置参数,args是一个元组.缺省参数放可变参数后面
# **kwargs接收多余的关键字参数, kwargs是一个字典
def func(a, b, *args， mul=1， **kwargs):	
    print(a, b)
    print(args)
    print(kwargs)
    
func(val1, val2, val3, val4, val5)

# 传入可迭代对象 
def add_many(iter):
	for n in iter:
        ......
# 例：
list = [val, val2, val3, val4]
func(list)



# 可变类型和不可变类型传参

函数的返回值

# return 表示函数的结束
def func()
	return x

# 返回多个值： 返回列表  返回字典， 元组
def func()
	return x, y		# 元组

递归函数

# 函数自己调用自己，最重要的就是设置停止条件
# 递归有深度规定
# break不能用于函数递归

count = 0
def func():
	global count += 1  # 在函数内部使用全局变量 需要加global
    if count < 10:
        func()

# 求和
def get_sum(n)
	if n == 0:
        return 0
    return get_sum(n-1) + n

匿名函数

def func(a, b):
	return a + b
# 给函数起别名
add = func
x = add(3,4)

# lambda 表达式 匿名函数
lambda a,b: a + b	  # lambda  参数： 返回值

# 匿名函数调用
# 1. 不常用：定义一个名字
name = lambda a, b : a + b
x = name(4, 5)

# 2.常用， 将函数当做参数传给另一个函数使用 回调函数
def calc(a,b,fn):
    c = fn
    return c

result = calc(5, 7, lambda x, y: x + y)
result2 = calc(2,2, lambda x, y: x * b)

列表中的一些内置函数和内置类

# 列表的sort方法：nums.sort() 会对原列表进行排序
# x = sorted(nums) 会将原列表进行排序生成一个新列表
nums= [4, 8, 2, 1, 7, 6]



student = [
    {'name':'sunqg', 'addr': 'hebie','age':22, 'score': 99},
    {'name':'sunqw', 'addr': 'hebei','age':12, 'score': 86},
    {'name':'sunhx', 'addr': 'hebei','age':47, 'score': 45}
    {'name':'liyal', 'addr': 'hebie','age':38, 'score': 66}
]
# 字典与字典之间不能进行比较，缺少比较规则
# 需要传key 指定比较规则
# key 的类型是一个函数
def foo(ele):
    return ele['age']

# sort调用了foo方法 并传递了一个参数
student.sort(key=foo)
# 使用lambda实现
student.sort(key=lambda ele:ele['age'])

# 内置函数和内置类都在bulitins.py里
# filter map reduce

# filter(func, iter) 对可迭代对象进行过滤 返回值为一个filter可迭代对象
# 根据函数func， 对迭代对象iter进行过滤
age = [12, 23, 45, 15 , 32, 41,  16] 
iter = filter(lambda ele:ele > 18, ages)
for x in iter:
    print(x)
    
# map(func, iter) 将可迭代对象中的每一个元素都执行以下函数
# reduce(fun, squ) 
from functools import reduce
reduce(lambda ele1, ele: ele1+ele['age'], students)	# 求和  递归

高阶函数

一个函数作为另一个函数的返回值 函数的嵌套

一个函数作为另一个函数的参数 lambda表达式

函数内部再定义一个函数

def foo():
	print('我是foo，我被调用了')
    return 'foo'

def bar():
    print('我是bar，我被调用了')
    return foo

x = bar()		# 此时x是foo的别名
x()				# 调用foo
y = bar()()		# 先调用bar 再调用foo

闭包

def outer():
	x = 10
	def inner():
        # 在内部函数修改外部函数的局部变量
        nonlocal x
        y = x + 1
		x = 20		# 新定义的x
    return inner

outer()  # print =>  i am outer     inner只能在函数内部被调用

# 内部函数被认为是闭包

# 计算一段代码的执行时间
# 时间戳:从1970-01-01 00:00:00 到现在的秒数
import time
def cal_time(fn):
    start = time.time()
    fn()
    end = time.time()
    print("代码{}的执行时间为{}".format(fn, end-start))

def demo():
    ......
    pass

def demo2():
    ......
    pass

cal_time(demo)
cal_time(demo2)

装饰器

# 使用装饰器计算代码执行时长
def cal_time(fn):
    print('外部函数')
    def inner(x, *args, **kwargs):
        start = time.time()
        s = fn(x)
        end = time.time()
        print('代码耗时', end-start)
        return s
    return inner

@cal_time
def demo()
	pass


demo()

@cal_time:

​ 先调用外部函数

​ 将被装饰的函数传递给装饰器函数

​ 当再次调用被装饰函数时：执行的是inner函数

def cal_time(fn)
	def inner():
        s = fn()
        return s
@cal_time
def demo():
    x = 10
    return x

m = demo  # print => x

def cal_time(fn):
    def inner(x):
        start = time.time()
        fn(x)
        return x

@cal_time
def demo(x):
    return x

m = demo(x)    # print => m=x
    	

# 使用装饰器添加限制
def is_login(fn)
	def inner(*args, **kwargs)
    	result = fn()
    	return result
	return inner

 @is_login
 def view()