Python进阶知识：迭代/生成器、函数式编程、闭包、装饰器

迭代/生成器：

# 迭代器：iter和next
l = [1, 2, 3, 4]
it = iter(l)
print(next(it))
print(next(it))
print(next(it))
print(next(it))

# while循环
l = [1, 2, 3, 4]
lens = len(l)
i = 0
it = iter(l)
while i < lens:
    print(next(it))
    i += 1

# 自定义迭代器
class MyIter:
    def __init__(self, start, end):
        self.current = start
        self.end = end

    def __iter__(self):
        return self

    def __next__(self):
        if self.current >= self.end:
            raise StopIteration

        self.current += 1
        return self.current - 1

it = MyIter(1, 5)
for x in it:
    print(x)

# 生成器：
# 生成器函数：yield表达式
def myrange(stop):
    i = 0
    while i < stop:
        yield i
        i += 1

it = myrange(5)
print(next(it))
print(next(it))
print(next(it))

# 生成器表达式：与元组推导式格式相同
# (表达式 for 变量 in 迭代器 if 条件表达式)
for i in (x ** 2 for x in [1, 2, 3, 4]):
    print(i)

# 练习：斐波那契数列
# 通过迭代实现
def fib_loop(n):
    l = []
    a, b = 0, 1
    l.append(a)
    l.append(b)
    for _ in range(2, n):
        l.append(a + b)
        a, b = b, a + b

    print(l)

fib_loop(10)

函数式编程：

# 函数式编程
# 核心特征：1.纯函数；2.不可变类型；3.高阶函数
# 纯函数：函数按照传入的参数值进行运算，但不修改变量的值
# 高阶函数：可以使用一个函数名作为参数传入的函数
# 使用高阶函数进行编程的模式，叫做函数式编程

# 1.纯函数：f(x)+f(y)
# 2.不可变参数：x，y
# 3.函数名作为参数传递：f
def add(x, y, f):
    return f(x) + f(y)

def myPower(x):
    return x ** 2

s = add(1, -5, abs)
print(s)
s1 = add(1, -5, myPower)
print(s1)

# 将列表中的元素值平方
it = map(myPower, [1, 2, 3, 4])
print(it)
print(list(it))

# 函数换成lambda表达式：将列表中的元素值平方
it = map(lambda x: x ** 2, [1, 2, 3, 4])
print(list(it))

# 把序列[1, 3, 5, 7, 9]变换成整数13579
from functools import reduce

def change(x, y):
    return x * 10 + y

num = reduce(change, [1, 3, 5, 7, 9])
print(num)

# 在一个 list 中，删掉偶数，只保留奇数
def is_odd(x):
    return x % 2 == 1

it = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9])
print(list(it))

# 桉绝对值大小排序
it = sorted([1, 2, -3, -6, 9, 10], key=abs, reverse=True)
print(it)

# 求最大值
m = max([1, 2, 3, -1, -2, -5])
print(m)

闭包：

# 闭包是指引用了此函数外部嵌套函数的变量的函数
# 闭包就是能够读取其他函数内部变量的函数
# 只有函数内部的嵌套函数才能读取局部变量
# 所以闭包可以理解成“定义在一个函数内部的函数,同时这个函数又引用了外部的变量“。
# 在本质上，闭包是将内部嵌套函数和函数外部的执行环境绑定在一起的对象。

# 闭包必须满足以下三个条件：
# 1.必须有一个内嵌函数
# 2.内嵌函数必须引用外部函数中变量
# 3.外部函数返回值必须是内嵌函数

# 示例
def give_yasuiqian(money):
    def child_buy(obj, m):
        nonlocal money
        if money > m:
            money -= m
            print(f"买{obj}花了{m}元还剩{money}元")
        else:
            print(f"买{obj}失败")

    return child_buy

b = give_yasuiqian(1000)
b("变形金刚", 200)
b("漫画三国", 100)
b("手机", 1300)

# 假设有两个方法：add(x,y)和mul(x,y)
def add(x, y):
    return x + y

def mul(x, y):
    return x * y

def outer(func):
    def inner(x, y):
        return func(x, y)

    return inner

add = outer(add)
print(add(1, 2))
mul = outer(mul)
print(mul(1, 2))

# 给定两个函数：
# def func1():
#     print("func1正在运行...")
#
# def func2():
#     print("func2正在运行...")
# 通过闭包实现在不修改原函数的前提下，在每个函数执行之前打印日志。

# 原函数
def func1():
    print("func1正在运行...")

def func2():
    print("func2正在运行...")

# 打印日志
def appendLog(func):
    print(f"{func.__name__}打印日志")

# 闭包
def funcOuter(func):
    def funcInner():
        appendLog(func)
        func()

    return funcInner

func1 = funcOuter(func1)
func1()
func2 = funcOuter(func2)
func2()

装饰器：

# 打印日志
def appendLog(func):
    print(f"{func.__name__}打印日志")

# 闭包
def funcOuter(func):
    def funcInner():
        appendLog(func)
        func()

    return funcInner

# 闭包函数名作为装饰器
@funcOuter
def func1():
    print("func1正在运行...")

@funcOuter
def func2():
    print("func2正在运行...")

# 添加装饰器后，不需要显式调用闭包的外函数
# func1 = funcOuter(func1)
func1()
# func2 = funcOuter(func2)
func2()

# func1()
# func2()

# 装饰器的作用：在不修改原函数的前提下，添加额外的功能
# 带参数的装饰器
def outer(func):
    def inner(*args, **kwargs):
        return func(*args, **kwargs)

    return inner

@outer
def sum(a, b, c):
    return a + b + c

print(sum(1, 2))
print(sum(1, 2, 3))

# 装饰器链示例:
def uppercase(func):
    def wrapper(*args, **kwargs):
        result = func(*args, **kwargs)
        return result.upper()

    return wrapper

def exclamation(func):
    def wrapper(*args, **kwargs):
        result = func(*args, **kwargs)
        return result + "!"

    return wrapper

# 装饰器链：@exclamation装饰器是从内到外依次应用的
# 在代码中，首先应用的是 `@uppercase`，然后是 `@exclamation`
@uppercase
def say_hello(name):
    return f"Hello, {name}"

greeting = say_hello("Bob")
print(greeting)  # 输出 "HELLO, BOB!"

# 类装饰器：定义一个类，在类中实现__init__和__call__
# __init__：将被装饰的函数名作为参数传递给类进行初始化
# __call__：在该方法中调用被装饰的函数
# 并且可以在函数调用的前后添加其他的功能，最后返回结果
class MyDecoratror:
    def __init__(self, func):
        self.func = func

    def __call__(self, *args, **kwargs):
        # 在函数调用前执行的功能
        print("函数调用前执行的功能")
        result = self.func(*args, **kwargs)
        # 在函数调用后添加功能
        print("函数调用后执行的功能")
        return result

@MyDecoratror
def say(name):
    print(f"hello {name}")

say("zhangsan")