Python基础：高阶函数

#====================高阶函数=================
'''
1、python中所有变量都可以理解为指针
2、函数名是函数的指针，也可以理解为一个变量，也可以将函数名赋值给另个变量
3、高阶函数：既然变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数
'''
print(abs)
f = abs
print(f)
abs=1000#变量重新赋值
print(f(-100))
print(abs)
#高阶函数
def add(x, y, f):
    return f(x,y)
print(add(-10,50,max))

abs=f
#====================map()和reduce()函数=================
'''
1、map函数：map()函数接收两个参数，一个是函数，一个是Iterable，
map将传入的函数依次作用到序列的每个元素，并把结果作为新的Iterator返回。
2、reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4) 
这个函数必须接收两个参数
'''
#map函数
def f(x):
    return x * x
L=[1, 2, 3, 4, 5, 6, 7, 8, 9]
R=map(f,L)
print(R)
print(list(R))
#reduce函数
from functools import reduce
def fn(x, y):
    return x * 10 + y
x=reduce(fn,L)
print(x)

#====================filter()函数=================
'''
1、filter()函数用于过滤序列。
和map()类似，filter()也接收一个函数和一个序列。和map()不同的是，
filter()把传入的函数依次作用于每个元素，然后根据返回值是True还是False决定保留还是丢弃该元素。
'''
#求解素数问题：埃氏筛法
def Primary():
    x=2  #1不是素数，所有初始序列从2开始
    while(True):
        yield x
        x+=1

def Choose(n):#用于多个参数的情况
    def fun(x):  #内部函数可以使用外部函数数据
        return x%n
    return fun

def Primes():
    it = Primary() # 初始序列迭代器
    while True:
        n = next(it) # 返回序列的第一个数
        yield n
        it = filter(Choose(n), it) # 原迭代器经过筛选返回新迭代器

P=Primes()  #素数生成器
for n in P:
    if n < 100:
        print(n,end="\t")
    else:
        break
print("")

#====================sorted函数=================
'''
sorted()函数也是一个高阶函数，它还可以接收一个key函数来实现自定义的排序
key指定的函数将作用于序列的每一个元素上，并根据key函数返回的结果进行排序。
要进行反向排序，可以传入第三个参数reverse=True：
'''
L=[36, 5, -12, 9, -21]
x=sorted(L)
print(x)
print(L)#原序列没有改变
x=sorted(L,key=abs)
print(x)
S=['bob', 'about', 'Zoo', 'Credit']
print(sorted(S))
print(sorted(S,key=str.lower))
print(sorted(S,key=str.lower,reverse=True))


#====================函数作为返回值=================
''''
内部函数sum可以引用外部函数lazy_sum的参数和局部变量，
当lazy_sum返回函数sum时，相关参数和变量都保存在返回的函数中，
这被称为闭包（Closure），同时可以保证多层调用相互独立
'''
def lazy_sum(*args):
    def sum():
        ax = 0
        for n in args:
            ax = ax + n
        return ax
    return sum

f = lazy_sum(1, 3, 5, 7, 9)#返回一个函数
print(f)
print(f(),f())
f1 = lazy_sum(10, 30, 50, 70, 90)
print(f1())
print(f==f1)

def count():
    fs = []
    for i in range(1, 4):
        def f():
             return i*i
        fs.append(f)
    return fs

f1, f2, f3 = count()
print(f1(), f2(), f3() )
'''
由这个例子可以看出，返回的函数和被掉的原函数一起被闭包，
但是当调用一次count()是返回了三个函数，所有这三个函数共享一个外层函数
因为返回函数没有马上调用，所有当count()执行到return是i已经为3了

返回闭包时牢记一点：返回函数不要引用任何循环变量，或者后续会发生变化的变量。
如果一定要引用循环变量怎么办？方法是再创建一个函数，用该函数的参数绑定循环变量当前的值，
无论该循环变量后续如何更改，已绑定到函数参数的值不变：
'''
def count():
    def f(j):
        def g():
            return j*j
        return g
    fs = []
    for i in range(1, 4):
        fs.append(f(i)) # f(i)立刻被执行，因此i的当前值被传入f()
    return fs
#这个时候函数g的外层函数为f，所有闭包的是f和g
f1, f2, f3 = count()
print(f1(), f2(), f3() )


#====================匿名函数=================
'''
关键字lambda表示匿名函数，冒号前面的x表示函数参数。
匿名函数有个限制，就是只能有一个表达式，不用写return，返回值就是该表达式的结果。
'''
#做参数
L=list(map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9]))
print(L)
#赋值调用
f=lambda x: x * x
print(f(5))

#==============装饰器=====================
def now():
    print('2015-3-25')
#装饰器(decorator)函数:参数和返回值都是一个函数
def log(func):
    def wrapper(*args, **kw):
        print('call %s():' % func.__name__)
        return func(*args, **kw)
    return wrapper
#添加装饰器
@log
def now():
    print('2015-3-25')
now()
'''
实际上是将当前函数now传入装饰器函数进行一番装饰在将返回函数给当前函数now
相当于：now=log(now)
'''
#如果decorator本身需要传入参数，那就需要编写一个返回decorator的高阶函数
def log(text):
    def decorator(func):
        def wrapper(*args, **kw):
            print('%s %s():' % (text, func.__name__))
            return func(*args, **kw)
        return wrapper
    return decorator
#这个地方相当于将log('execute')返回函数decorator放在@后
#即@decorator
@log('execute')
def now():
    print('2015-3-25')

#产看函数的名字，已经变了
print(now.__name__)
#一般需要保证名字不变，可以使用wrapper.__name__ = func.__name__
#但一般使用functools.wraps来干这个事
#即在定义wrapper()的前面加上@functools.wraps(func)即可。
import functools
def log(func):
    @functools.wraps(func)
    def wrapper(*args, **kw):
        print('call %s():' % func.__name__)
        return func(*args, **kw)
    return wrapper

def log(text):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kw):
            print('%s %s():' % (text, func.__name__))
            return func(*args, **kw)
        return wrapper
    return decorator

@log('execute')
def now():
    print('2015-3-25')
print(now.__name__)


#==============偏函数=====================
'''
functools.partial就是帮助我们创建一个偏函数的.
functools.partial的作用就是，把一个函数的某些参数给固定住（也就是设置默认值），返回一个新的函数
'''
print(int("1000000",base=2))
int2 = functools.partial(int, base=2)
print(int2('1000000'))
#创建偏函数时，实际上是为函数添加一些*args和**kw参数
#上面的int2就相当于
kw = { 'base': 2 }
print(int('10010', **kw))

max2 = functools.partial(max, 10)
#实际上会把10作为*args的一部分自动加到左边，也就是
print(max2(5, 6, 7))
args = (10, 5, 6, 7)
print(max(*args))