轻松学会python高级函数

1. 匿名函数lambda的使用

• 匿名函数：没有名字的函数，这种函数只使用一次，一般函数体只有一条语句一个返回值，用于实现简单功能

语法格式

• lambda 参数1, 参数2, 参数3, .... : 表达式

# 使用匿名函数接收两个参数a和b，返回a、b的较大值
fun7 = lambda a, b: max(a,b)
print(fun7(10,20))
# python中的三元运算符
# 结果1 if 条件 else 结果2
fun8 = lambda a, b : a if a>b else b
print(fun8(13,10))


输出结果
20
13

lambda函数的特性

1. lambda函数是匿名的，即它是没有名字的函数，并且自带return。
2. lambda函数可以使用任意数量的参数，但只能包含一个表达式。
3. lambda函数返回一个值，这个值就是表达式的结果。
4. lambda函数的生命周期很短，调用后立即被回收

2.高阶函数

• Python中的高阶函数：将一个或多个函数作为函数的参数

2.1 map 函数

• 用于将一个函数应用到一个序列的每一个元素，并返回一个包含结果的迭代器

语法格式

• map(函数，可迭代对象)

input_num = (1,2,3,4,5)
# 内置函数：str()   int()   float()
ret = map(str, input_num)
print(ret)
print(list(ret))

ls = [1,2,3,4,5]
ret = list(map(lambda x : x*10, ls))
print(ret)

输出结果

2.2 reduce函数

• reduce 函数用于对序列进行累计运算，它通常需要从 functools 模块中导入

语法格式

• from functools import reduce
• reduce(函数，可迭代对象)

from functools import reduce

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

ret_sum = reduce(lambda x, y: x+y, ls)
print(ret_sum)

ret_pro = reduce(lambda x, y: x*y, ls)
print(ret_pro)


输出结果
15
120

2.3 filter函数

• 用于遍历序列中的每个元素，根据条件进行筛选，返回一个包含被筛选后结果的迭代器

语法格式

• filter(函数, 可迭代对象)

import random

ls = [random.randint(10,30) for _ in range(10)]
print(ls)

ret = filter(lambda x : x%2==0, ls)
print(ret)
print(list(ret))

输出结果
[15, 23, 17, 14, 16, 25, 12, 10, 12, 18]

[14, 16, 12, 10, 12, 18]

2.4 排序函数

menu = [['h红烧牛肉面', 18], ['x香辣牛肉面', 16], ['a安徽板面', 15], ['c重庆小面', 20]]
# 排序
menu.sort()
print(menu)
# 按单价排序 —— itemgetter——获取多维数组中某个维度的元素值
import operator
menu.sort(key=operator.itemgetter(1), reverse=True)
print(menu)
# 按单价排序 —— 使用匿名函数
menu.sort(key=lambda x:x[1], reverse=False)
print(menu)



输出结果
[['a安徽板面', 15], ['c重庆小面', 20], ['h红烧牛肉面', 18], ['x香辣牛肉面', 16]]
[['c重庆小面', 20], ['h红烧牛肉面', 18], ['x香辣牛肉面', 16], ['a安徽板面', 15]]
[['a安徽板面', 15], ['x香辣牛肉面', 16], ['h红烧牛肉面', 18], ['c重庆小面', 20]]

练习题

1.有一个列表n=[1,2,3,4,5,6,7,8,9], 请使用匿名函数输出[10,20,30,40,50,60,70,80,90]

n=[1,2,3,4,5,6,7,8,9]
ret = list(map(lambda x:x*10,n))
print(ret)

输出结果
[10, 20, 30, 40, 50, 60, 70, 80, 90]

2.使用匿名函数做出递归效果，求50-100的累加和

ret = reduce(lambda x,y:x+y,range(50,101))
print(ret)


输出结果
3825

3.装饰器

3.1 装饰器的概念

• 在python中，装饰器本质是一个特殊的嵌套函数，它接收一个函数【被装饰的函数】做参数，并返回一个新的函数【装饰后的函数】

装饰器的最大作用

• 在不改变原有函数【被装饰的函数】的基础上给它添加新的功能

3.2 装饰器的基本用法

# 装饰器
def out_fun(function):
    def in_fun():
        print("挂上一颗星星")
        function()
        print("挂上一个礼物盒")
    return in_fun

# 被装饰函数
def my_tree():
    print("简简单单一棵树")

# 第一种调用方式
out_fun(my_tree)()
# 问：第一种调用方式，被装饰函数真的装饰了吗
my_tree()       # 并没有新增功能

# 第二种调用方式
my_tree = out_fun(my_tree)
# 问：第二种调用方式，被装饰函数真的装饰了吗
my_tree()


输出结果
挂上一颗星星
简简单单一棵树
挂上一个礼物盒
简简单单一棵树
挂上一颗星星
简简单单一棵树
挂上一个礼物盒

3.3 装饰器语法糖

• 语法糖是由编程语言提供的，可以让代码更加简洁、高效、易读和易写。语法糖不改变不会带来新的功能，也不会改变编程的结果，但是使用它会更加方便

python中的语法糖

1. 列表推导式
2. 集合推导式
3. 字典推导式
4. f-string print(f"{}")
5. 解包
6. 装饰器

语法格式

• @装饰器函数名
• def 被装饰函数名:
• 代码块

# 装饰器
def out_fun(function):
    def in_fun():
        print("挂上一颗星星")
        function()
        print("挂上一个礼物盒")
    return in_fun

# 被装饰函数
@out_fun
def my_tree():
    print("简简单单一棵树")

my_tree()


输出结果
挂上一颗星星
简简单单一棵树
挂上一个礼物盒

3.4 被装饰函数有参数

• 若被装饰函数有参数，那么装饰器的内部函数也需要有参数，保证在内部调用被装饰函数的时候能正确传参

3.4.1 被装饰函数有一个参数

# 装饰器
def out_fun(function):
    def in_fun(x):
        print("挂上一颗星星")
        function(x)
        print("挂上一个礼物盒")
    return in_fun

# 被装饰函数
@out_fun
def my_tree(x):
    print(f"简简单单{x}棵树")

my_tree(3)


输出结果
挂上一颗星星
简简单单3棵树
挂上一个礼物盒

3.4.2 被装饰函数有未知个参数

import time
# 装饰器
def out_fun(function):
    def in_fun(*args, **kwargs):
        start = time.time()
        function(*args, **kwargs)
        end = time.time()
        print(end - start)
    return in_fun

# 被装饰函数1
@out_fun
def fun1(x):
    time.sleep(1)
    print(x)
fun1(1)
# 被装饰函数2
@out_fun
def fun2(x, y, z):
    time.sleep(1)
    print(x + y + z)
fun2(1,2,3)


输出结果
1
1.0003464221954346
6
1.0008840560913086

3.5 装饰器带参数

• 装饰器的外部函数要接收被装饰函数的函数名，内部函数要接收被装饰函数的参数，那么为了保证装饰器参数、被装饰函数参数的正确传递，我们在装饰器外部函数再嵌套一层函数，用于接收装饰器参数

def decoration(dec_arg):
    def out_fun(function):
        def in_fun(x):
            print(dec_arg)
            print("挂上一颗星星")
            function(x)
            print("挂上一个礼物盒")
        return in_fun
    return out_fun

# 被装饰函数
@decoration("我是装饰器的参数")
def my_tree(x):
    print(f"简简单单{x}棵树")

my_tree(3)

输出结果
我是装饰器的参数
挂上一颗星星
简简单单3棵树
挂上一个礼物盒

3.6 装饰器嵌套

• 装饰器嵌套就是被装饰函数 可以 被多个装饰器装饰

# 装饰器1
def out_fun_1(function):
    def in_fun_1(*args, **kwargs):
        print("装饰器1开始调用")
        function(*args, **kwargs)
        print("装饰1结束调用")
    return in_fun_1

# 装饰器2
def out_fun_2(function):
    def in_fun_2(*args, **kwargs):
        print("装饰器2开始调用")
        function(*args, **kwargs)
        print("装饰2结束调用")
    return in_fun_2

# 嵌套装饰 被装饰函数
@out_fun_1
@out_fun_2
def my_tree(x):
    print(f"{x}棵树")

my_tree(3)

输出结果
装饰器1开始调用
装饰器2开始调用
3棵树
装饰2结束调用
装饰1结束调用

3.7 类装饰器

• 除了可以自定义一个新的函数用作装饰器之外，也可以将一个类作为装饰器，为被装饰的函数添加新的功能。类装饰器通过实现类的__call__方法，使得类的实例可以被当作函数来调用，丛而实现对其他函数的装饰