亿豪的python学习 day18

今天的学习内容

函数作为参数

将核心逻辑传入方法体，使该方法的适用性更广，体现了面向对象的开闭原则。
lambda 表达式
1. 定义：是一种匿名方法。
2. 作用：作为参数传递时语法简洁，优雅，代码可读性强。
随时创建和销毁，减少程序耦合度。
3. 语法
– 定义：
变量 = lambda 形参: 方法体
– 调用：
变量(实参)
4. 说明：
– 形参没有可以不填
– 方法体只能有一条语句，且不支持赋值语句。

内置高阶函数

1. map（函数，可迭代对象）：使用可迭代对象中的每个元素调用函数，将返回值作为新可迭代对象元素；返回值为新可迭代对象。
2. filter(函数，可迭代对象)：根据条件筛选可迭代对象中的元素，返回值为新可迭代对象。
3. sorted(可迭代对象，key = 函数,reverse = bool值)：排序，返回值为排序结果。
4. max(可迭代对象，key = 函数)：根据函数获取可迭代对象的最大值。
5. min(可迭代对象，key = 函数)：根据函数获取可迭代对象的最小值。

函数作为返回值

逻辑连续，当内部函数被调用时，不脱离当前的逻辑。

闭包

1. 三要素：
   – 必须有一个内嵌函数。
   – 内嵌函数必须引用外部函数中变量。
   – 外部函数返回值必须是内嵌函数。
2. 语法
   – 定义：

def 外部函数名(参数):
		外部变量
		def 内部函数名(参数):
			使用外部变量
		return 内部函数名

– 调用：
变量 = 外部函数名(参数)
变量(参数)
3. 定义：在一个函数内部的函数,同时内部函数又引用了外部函数的变量。
4. 本质：闭包是将内部函数和外部函数的执行环境绑定在一起的对象。
5. 优点：内部函数可以使用外部变量。
6. 缺点：外部变量一直存在于内存中，不会在调用结束后释放，占用内存。
7. 作用：实现python装饰器。

函数装饰器decorator

1. 定义：在不改变原函数的调用以及内部代码情况下，为其添加新功能的函数。
2. 语法

def 函数装饰器名称(func):
    def 内嵌函数(*args, **kwargs):
        需要添加的新功能
        return func(*args, **kwargs)
return内嵌函数

	   原函数 = 内嵌函数
@ 函数装饰器名称
def 原函数名称(参数):
		函数体

原函数(参数)

3. 本质：使用“@函数装饰器名称”修饰原函数，等同于创建与原函数名称相同的变量，关联内嵌函数；故调用原函数时执行内嵌函数。
   原函数名称 = 函数装饰器名称（原函数名称）

4. 装饰器链：
   一个函数可以被多个装饰器修饰，执行顺序为从近到远。

匿名函数

"""
    lambda 匿名函数：
        语法：lambda 参数:函数体
        价值：作为实参传递给函数
"""
# 有参数 有返回值
# def fun01(a):
#     return a == "ok"
#
#
# re = fun01("ok")
# print(re)

# 形参 = 实参
fun01 = lambda a: a == "ok"
# 函数体
re = fun01("ok")
print(re)


# 有多参数 有返回值
# def fun02(a, b, c):
#     return a == b == c


fun02 = lambda a, b, c: a == b == c
re = fun02(1, 2, 3)
print(re)

内置高阶函数

class Wife:
    """
        抽象的数据
    """

    def __init__(self, name="", age=0, height=0, weight=0):
        self.name = name
        self.age = age
        self.height = height
        self.weight = weight

    def __str__(self):
        return "%s--%d--%d--%d" % (self.name, self.age, self.height, self.weight)


list01 = [
    Wife("铁锤", 27, 190, 200),
    Wife("铁钉", 37, 165, 160),
    Wife("铁棒", 24, 160, 190),
    Wife("铁锅", 23, 190, 100),
]
# 需求：在老婆列表中，查找所有体重大于160的老婆对象

# 1. filter 过滤器
for item in filter(lambda element: element.weight > 160, list01):
    print(item)

# 需求：在老婆列表中，查找所有老婆的姓名与体重

# 2. map 映射
for item in map(lambda e: (e.name, e.weight), list01):
    print(item)

# 需求：在老婆列表中，查找最重的老婆


# 3. 获取最大
re = max(list01, key=lambda item: item.weight)
print(re)

# 4. 排序
# 修改列表内部元素 --> 无需通过返回值传递结果
# 返回排序后的列表

for item in sorted(list01, key=lambda item: item.weight,reverse=True):
    print(item)

闭包

调用函数，在内存中开辟栈帧。
函数执行过后，栈帧释放，局部变量销毁。
外部函数执行过后，不释放栈帧(留给内部函数使用)。

import time

# 使用装饰器，拦截对旧功能的调用
# 将新功能与旧功能包装在一起
def print_execute_time(func):
    def wrapper(*args, **kwargs):
        start_time = time.time()
        # func -- 旧功能
        re = func(*args, **kwargs)
        stop_time = time.time()
        # 新功能 -- 打印执行时间
        print(stop_time - start_time)
        return re

    return wrapper


@print_execute_time  # print_execute_time(fun01)
def fun01():
    time.sleep(2)  # 睡眠2秒，用于模拟计算2秒钟


@print_execute_time
def fun02(a):
    time.sleep(3)  # 睡眠3秒