小白的python之旅（十三）--匿名函数，递归函数，高阶函数，装饰器

小白的python之旅（十三）–匿名函数，递归函数，高阶函数，装饰器

1，匿名函数的定义和使用

# 1. 什么是匿名函数
"""
匿名函数本质还是函数，普通函数中除了定义的语法其他全部适用于匿名函数

1)定义匿名函数的语法：
函数名 = lambda 形参列表:返回值

说明：
lambda  -  关键字，固定写法
形参列表  -  '形参1,形参2,...' 的形式存在
:   -   固定写法
返回值   -   写任何有结果的表达式

2)调用匿名函数: 函数变量(实参列表)
匿名函数的本质就是类型是function的数据, 普通数据能做的它都可以做
"""
# 定义一个匿名函数求两个数的和
x = lambda num1, num2: num1+num2    # function

"""
def x(num1, num2):
    return num1 + num2
"""

a = 10    # int
b = 'abc'  # str
c = [10, 20, 30]   # list
d= {'a': 230, 'b': 100}    # dict

# 调用匿名函数
print(x(100, 200))

list1 = [10, 'abc', lambda num1, num2: num1+num2]
print(list1[0] + 10 - 100)
print(list1[1].join(['10', '20', '30']))
print(list1[2](1, 3))      # 4


# 练习1: 写一个匿名函数用来判断指定的年龄是否成年，根据情况返回 True/False
is_adult = lambda age: '成年' if age >= 18 else '未成年'
print(is_adult(87))

2，递归函数以及常用例子

# 1.什么是递归函数
"""
在函数内调用函数本身的函数就是递归函数(自己调用自己)

循环能做的事情递归都可以做
"""


# func1就是递归
def func1():
    print('函数1')
    func1()


# func1()

# 2.怎么使用递归
"""
第一步：确定临界值(在临界值的位置结束函数)
第二步：找关系(找当次循环(f(n))和上一次循环(f(n-1))之间的关系)
第三步：假设函数的功能已经实现，用f(n-1)去实现f(n)的功能
"""


# 写一个递归函数：计算1+2+3+4+..+n
# f(n) = 1+2+3+4+..+n-1+n
# f(n-1) = 1+2+3+4+...+n-1
def yt_sum(n):
    # 1.找临界值
    if n == 1:
        return 1

    # 2.关系: yt_sum(n) = yt_sum(n-1)+n
    return yt_sum(n-1) + n


print(yt_sum(100))


def yt_sum(n):
    sum1 = 0
    for x in range(n+1):
        sum1 += x
    return sum1

# 2.用递归计算斐波那契数列第20个数：1，1，2，3，5，8，13，21，34，...
def series(n):
    # 1.找临界值
    if n == 1 or n == 2:
        return 1
    # 2.找关系： series(n) = series(n-1) + series(n-2)
    return series(n-1) + series(n-2)


print(series(5))   # print(5)

3，高阶函数

python中常用高阶函数filter，map，reduce，max，min，sorted

# 1. 函数就是变量(**)
"""
python中定义函数其实就是定义一个类型是 function 的变量，函数名就是变量名
"""


def func1():
    print('函数1')


# 1)查看变量的类型
a = 10
print(type(a))    # <class 'int'>
print(type(func1))    # <class 'function'>

# 2)用一个变量给另外一个变量赋值
b = a
print(b+20)
c = func1
c()

# 3)查看变量的地址
print(id(a))
print(id(func1))

# 4)修改变量的值
a = 100
# func1 = 'abc'

# 5)变量可以作为序列的元素
a = 200
list1 = [a, 10, 20, 30, func1, func1()]
print(list1)
print(list1[-2]())


# 2. 高阶函数
"""
1)实参高阶函数：参数是函数的函数就是实参高阶函数
"""


# a.变量可以作为函数的参数（实参）
def func2(x):
    print(x)


m = 12.5
func2(10)
func2(m)


# b.实参高阶函数
def func3(x):
    print(x(1, 2))


func3(lambda m, n: m+n)

# c.系统提供的常见的实参高阶函数
"""
a.
max、min、sorted都是实参高阶函数，有一个参数key需要传一个函数；被传入的函数需要一个参数和一个返回值，这个参数指向的是序列中的元素，返回值是比较对象
"""
# 示例一：求列表中数字各位数和最大的元素
list2 = [19, 90, 78, 67]
def func3(item):
    # 个位数最大的元素
    # return item%10
    # 各位数的和的最大值
    sum1 = 0
    for x in str(item):
        sum1 += int(x)
    return sum1


print(max(list2, key=func3))

# 示例二：求列表中个位数最大的元素
print(max(list2, key=lambda item: item % 10))

# 练习1：用max函数获取学生列表中成绩最高的学生
students = [
    {'name': '张三', 'age': 18, 'score': 89},
    {'name': '小明', 'age': 29, 'score': 60},
    {'name': '李四', 'age': 25, 'score': 90},
    {'name': 'Tom', 'age': 19, 'score': 87}
]

# 获取成绩最高的学生
best_stu = max(students, key=lambda item: item['score'])
print(best_stu)

# 获取年龄最小的学生
min_stu = min(students, key=lambda item: item['age'])
print(min_stu)

# 将学生列表按照年龄值从小到大排序
new_students = sorted(students, key=lambda item: item['age'])
print(new_students)

"""
b.
map函数
map(函数,序列)  - 将序列中所有的元素按照函数指定的规则进行转换, 返回的是map的对象(map就是容器型数据类型中的一种)。
                 函数需要一个参数和一个返回值，参数指向的是序列中的元素，返回值就是用来替换原来元素的新元素
"""
list3 = [10, 20, 30, 40]

# 示例1：将列表list3中所有的元素都加1 -> [11, 21, 31, 41]
new_list3 = map(lambda item: item+1, list3)
print(new_list3, list(new_list3))

# 示例2：将列表list3中的所有的元素都转换成对应的字符串： ['10', '20', '30', '40']
new_list3 = map(str, list3)
print(list(new_list3))    # ['10', '20', '30', '40']

#c。
# filter函数 filter(函数，序列)---用来过滤序列中不符合函数返回值所对应的元素
# 函数需要一个参数和返回值，参数指向的是序列中的元素，返回值就是用来删除不符合元素的，需要进行转换
print(list(filter(lambda x: x % 10 == 0, list1)))  # [10, 30, 20]

"""
d。
reduce(函数，序列) - 对序列中的元素按照函数提供的功能进行累积的操作
                   函数需要两个参数,第一个参数是初始化或者上次运算的结果，y指向每一个元素
reduce(函数，序列, 初始值)
"""
from functools import reduce

list3 = [10, 20, 30, 40]

# 示例一： 求所有元素的和
result = reduce(lambda x, y: x+y, list3)
print(result)

# 示例二：求所有元素的乘积
result = reduce(lambda x, y: x*y, list3)
print(result)

# 示例三：求整个班级所有学生的总成绩
students = [
    {'name': '张三', 'age': 18, 'score': 89},
    {'name': '小明', 'age': 29, 'score': 60},
    {'name': '李四', 'age': 25, 'score': 90},
    {'name': 'Tom', 'age': 19, 'score': 87}
]
result = reduce(lambda x, y: x + y['score'], students, 0)
print(result)


# reduce原码（粗糙的！）
def yt_reduce(func, seq, inter=None):
    if inter is None:
        x = seq.pop(0)
    else:
        x = inter

    for item in seq:
        x = func(x, item)

    return x


result = yt_reduce(lambda x, y: x+y['score'], students, 0)
print(result)


"""
2)返回值高阶函数：返回值是函数的函数
"""


# func1是返回值高阶函数
def func1():
    def func2(x, y):
        return x + y
    return func2


print(func1()(100, 200))    # func2(100, 200)

4，装饰器的使用与定义

# 1.装饰器的作用
"""
在不修改函数的情况下给函数添加新的功能
"""
# 2.什么是装饰器
"""
装饰器的本质就是一个函数（这个函数是一个实参高阶函数也是返回值高阶函数）

无参装饰器的写法：
def 函数名1(函数名2):
    def 函数名3(*agrs, **kwargs):
        新功能代码
        返回值 = 函数名2(*agrs, **kwargs)
        return 返回值
    return 函数名3
    
说明:
函数名1  -  装饰器名字，命名的时候和这个装饰器要添加的功能进行关联
函数名2  -  随便命名，指向被添加功能的函数; 可以命名成 fn
函数名3  -  随便命名，在原函数上添加完新的功能以后产生的新的函数
新功能代码 - 实现新加的功能的代码
"""


# 写一个装饰器，在函数开始执行前打印'函数开始'
def start_function(fn):
    def new_fn(*args, **kwargs):
        print('函数开始')
        result = fn(*args, **kwargs)
        return result
    return new_fn


@start_function
def yt_sum(num1, num2):
    print(num1 + num2)


@start_function
def print_star(n):
    print('*'*n)


@start_function
def factorial(n):
    sum1 = 1
    for x in range(1, n+1):
        sum1 *= x
    return sum1

yt_sum(10, 20)
print_star(8)

yt_sum(100, 200)

print(factorial(5))

"""
函数开始
30

函数开始
********
"""


# 练习1：写一个装饰器将返回值是字符串的函数，返回值中所有的小写字母变成大写字母。
def yt_upper(fn):
    # fn = str_func
    def new_fn(*args, **kwargs):
        result = fn(*args, **kwargs)
        if type(result) == str:
            return result.upper()
            # new_result = ''
            # for x in result:
            #     if 'a' <= x <= 'x':
            #         new_result += chr(ord(x)-32)
            #     else:
            #         new_result += x
            # return new_result
        else:
            return result
    return new_fn


@yt_upper
def str_func():
    return 'abc'


"""
装饰器的本质：

@yt_upper
def str_func():
    return 'abc'
    
相当于：

def str_func():
    return 'abc'
str_func = yt_upper(str_func)     #   str_func = new_fn
"""


# @yt_upper
# def num_func():
#     return 100



print(str_func())


# print(num_func())

print('===================================')
# 补充：定义函数的时候*args和**kwargs同时存在的意义 - 不定参数的函数在调用的时候既可以使用位置参数也可以使用关键字参数
def func1(*args, **kwargs):
    pass


func1(20, 90, 90)
func1(a=20, b=9)
func1(1, 3, 4, a=3, b=5, c=90)


def func3(x, y, z):
    print(f'x:{x}, y:{y}, z:{z}')


def func2(*args, **kwargs):
    # args = (10, 20, 30)
    # kwargs = {}
    func3(*args, **kwargs)    # func3(10, 20, 30)   func3(*(10, 20, 30))  -> func3(10, 20, 30)


func2(10, 20, 30)
func3(x=20, y=90, z=300)