迭代器，生成器，装饰器，闭包，高阶函数

'''
迭代器：iter和next
'''
list1 = [1,1,3,4,5]
it = iter(list1)
print(next(it))
print(next(it))
print(next(it))

list1 = [1,2,3,4,5]
len=len(list1)
for i in range(len):
    print(list1[i])

'''
自定义迭代器
'''
class Myiter:
    def __init__(self,start,end):
        self.start=start
        self.end=end
    def __iter__(self):
        return self
    def __next__(self):
        if self.start >= self.end:
            raise StopIteration
        self.start = self.start + 2
        return self.start
it = Myiter(1,10)
for i in it:
    print(i)
'''
生成器：
生成器函数：yield 表达式
生成器表达式：跟元组推导式格式一样（表达式 for 变量 in 迭代器 if 条件表达式）
'''
##生成器函数
def myrange(stop):
    i=0
    while i<stop:
        yield i
        i+=1
it = myrange(10)
print(next(it))
print(next(it))
print(next(it))
print(next(it))

##生成器表达式
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 i in range(2,n):
        l.append(a+b)
        a, b = b, a+b
    print(l)
fib_loop(10)

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

#高阶函数：
def add(a,b,f):
    #这里的f函数的实现就是纯函数，a,b 就是不可变数据，函数名f作为形参传递
    return f( a) +f ( b )
def mypower(x):
    return x ** 2
s=add(1,2,abs)
print(s)
s1=add(1,2,mypower)
print(s1)

'''
map(函数，可迭代对象)
map()函数接收两个参数，一个是函数，一个是Iterable，map将传入的函数依次作用到序列的每个元素，
~并把结果作为新的Iterator返回。
'''

## 将列表中的元素值平方
def f(x):
    return x * x
r = map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])
print(list(r))

'''
reduce(函数，可迭代对象)** 
`reduce`把一个函数作用在一个序列`[x1, x2, x3, ...]`上，这个函数必须接收两个参数，
~`reduce`把结果继续和序列的下一个元素做累积计算，
~其效果就是：reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)
使用该内置函数需要导包  from functools import reduce
'''

# 把序列[1, 3, 5, 7, 9]变换成整数13579
from functools import reduce
def fn(x, y):
    return x * 10 + y
result = reduce(fn, [1, 3, 5, 7, 9]) # 13579
print(result)

'''
filter(函数，可迭代对象)

- 根据条件筛选可迭代对象中的元素，返回值为新可迭代对象。
'''
# 在一个 list 中，删掉偶数，只保留奇数
def is_odd(x):
    return x % 2 != 0
it=filter(is_odd, [1, 2, 3, 4, 5])
print(list(it))

'''
sorted(可迭代对象, key=函数, reverse=True)

- 排序，返回值为排序后的列表结果。 
'''
## 按绝对值大小排序
test=sorted([36, 5, -12, 9, -21], key=abs, reverse=True)
print(test)

'''
max(可迭代对象, key = 函数)

- 根据函数获取可迭代对象的最大值。
'''
# # 求最大值
m=max([36, 5, -12, 9, -21], key=abs)
print(m)

'''
min(可迭代对象，key = 函数)

- 根据函数获取可迭代对象的最小值。
'''
# # 求列表中单词长度最大的元素
words = ["apple", "banana", "cherry"]
longest_word = max(words, key=len)
print(longest_word)  # 输出: "banana"

'''
lambda 表达式  
变量 = lambda 形参: 方法体
'''
# 将列表中的元素值平方
def f(x):
    return x * x
r = map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])
print(list(r))
# 改造为lambda表达式
r= map(lambda x:x * x,[1, 2, 3, 4, 5, 6, 7, 8, 9])
print(list(r))

#闭包示例
# 闭包必须满足以下三个条件：
#
# - 必须有一个内嵌函数
# - 内嵌函数必须引用外部函数中变量
# - 外部函数返回值必须是内嵌函数。
def give_yasuiqian(money):
    def child_buy(obj, m):
        nonlocal money
        if money > m:
            money -= m
            print('买', obj, '花了', m, '元, 剩余', money, '元')
        else:
            print("买", obj, '失败')
    return child_buy
cb = give_yasuiqian(1000)
cb('变形金刚', 200)
cb('漫画三国', 100)
cb('手机', 1300)

'''
假设有两个方法：add(x,y)和mul(x,y)，使用闭包实现，既可以调用add，也可以调用mul方法
'''
def outer(func):
    def inner(x,y):
        return func(x,y)
    return inner
def add(x,y):
    return x + y
def mul(x,y):
    return x * y
inner = outer(add)
print(inner(1,2))
inner = outer(mul)
print(inner(1,2))

'''
给定两个函数：
def func1():
    print("func1正在运行...")

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

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

#闭包处理
def outter(func):
    def inner():
        appendLog(func)
        func()
    return inner


@outter#效果等同于 func1 = outter(func1)
def func1():
    print("func1正在运行...")
@outter# func2 = outter(func2)   这个装饰器的名字就是闭包外部函数的函数名
def func2():
    print("func2正在运行...")

func1()
func2()

'''
装饰器：在不修改原函数的前提下，添加额外的功能
带参装饰器
'''
def outer(func):
    def inner(*args,**kwargs):
        return func(*args,**kwargs)
    return inner
@outer
def sum(a,b):
    return a+b
@outer
def add(a,b,c):
    return a+b+c

print(sum(1,2))
print(add(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
def say_hello(name):
    return f"Hello, {name}"

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

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

class MyDecorator:
    def __init__(self, func):
        self.func = func

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

@MyDecorator  # 应用类装饰器
def say_hello(name):
    print(f"Hello, {name}!")

say_hello("Charlie")  # 调用被装饰的函数