在Python中，变量可以指向函数函数名也是变量既然变量可以指向函数，函数的参数能接收变量， <<<那么一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数。>>>

map(function, iterable, …)

map(function, iterable, …)

功能
将第一个参数 function 依次作用在参数可迭代对象中的每一个元素上，
返回包含每次 function 函数返回值的新迭代器

参数
function – 函数，有两个参数
iterable – 俩个可迭代对象（如：序列）

返回值
Python 3.x 返回迭代器

def func(a,b):

    return a * b
     #map第一个实参写函数名
                            #实参以最少的一方为准
ss = map(func,[1,2,3,4,5],[1,2,3,4,5,6,7,8,9])
for i in ss:    #用迭代器输出
    print(i)

reduce(function, iterable[, initializer])

reduce(function, iterable[, initializer])

功能
函数将一个数据集合（链表，元组等）中的所有数据进行下列操作：
用传给 reduce 中的函数 function（有两个参数）先对集合中的第 1、2 个元素进行操作，
得到的结果再与第三个数据用 function 函数运算，最后得到一个结果。

其效果类似：reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)

参数
function – 函数，有两个参数
iterable – 可迭代对象
initializer – 可选，初始参数

返回值
返回函数计算结果。

俩种书写格式

# 1.0
import functools
# # 2.0
# from functools import reduce
#
ret = functools.reduce(lambda a,b:a*b, [11,22,33,44,55])
print(ret)

filter(function, iterable)

filter(function, iterable)

功能
该接收两个参数，第一个为函数，
第二个为序列，序列的每个元素作为参数传递给函数进行判断，
然后返回 True 或 False，最后将返回 True 的元素放到新迭代器对象中

参数
function – 判断函数
iterable – 可迭代对象（如：序列）

返回值
返回一个迭代器对象

def func(n):
    return n % 2 == 0

ret = filter(func,range(1,101))

print(list(ret))        #迭代器



ret = filter(lambda a: a % 3 == 0 ,range(10))
print(list(ret))

sorted(iterable, key=abs, reverse=False)

sorted(iterable, key=abs, reverse=False)
#可迭代对象 #绝对值 #排序

功能
对所有可迭代的对象进行排序操作

参数
iterable – 可迭代对象。
key – key指定的函数将作用于可迭代对象上的每一个元素，并根据key函数返回的结果进行排序
reverse – 排序规则，reverse = True 降序 ， reverse = False 升序（默认）

返回值
返回重新排序的列表

ss = sorted([11,55,66,88,52,3,9,8,68],reverse=True)
print(ss)

绝对值
ss = sorted([11,55,-66,88,-52,3,9,-8,68],key=abs,reverse=True)
print(ss)

lambda表达式(匿名函数)

匿名函数的另一个别称是“lambda表达式”

lambda表达式的语法：
lambda argument_list: expression

def func(a,b):
    print(a+b)


# lambda 格式：
# lambda 形参:表达式或者返回值

f = lambda a,b:print(a + b)       #有参无返
f(1,10)


ff = lambda a,b:a*b          #有参有返
print(ff(6,8))

递归函数

在函数内部，可以调用其他函数。

如果一个函数在内部调用自身本身，这个函数就是递归函数。

# 阶乘
# 1！= 1*1
# 2！= 1*2
# 3！= 1*2*3

def func(n):
    if n == 1:
        return 1
    else:       #n * (n-1)
        return n * func(n-1)    #调用本身

print(func(100))

斐波那契数列

def func(n):
    if n == 1 or n == 2:
        return 1
    else:
        return func(n-1) + func(n-2)
print(func(10))

返回函数 闭包

外层函数返回内层函数的引用 – 起到了让内层函数执行的目的

#返回函数
# def outer():

#     def inner():

#         return sum([i for i in range(1,101) if i % 2 == 0])

#     return inner()      #外层函数返回内层函数的引用 -- 起到了让内层函数执行的目的

# print(outer())



def outer(n):

    def inner():

        return sum([i for i in range(1,n+1) if i % 2 == 0])

    return inner      #外层函数返回内层函数的引用 -- 起到了让内层函数执行的目的

print(outer(100)())

闭包是“返回函数”的一个典型应用

闭包的定义：
在一个外函数中定义了一个内函数， #函数的嵌套
内函数里运用了外函数的临时变量， #嵌套作用域变量
并且外函数的返回值是内函数的引用。 #返回函数
这样就构成了一个闭包。

# 闭包
def outer():
    a= 100
    def inner():
        b = a+ 1
        print("b=",b)
    return inner
outer()()

偏函数由functools.partial创建

偏函数由functools.partial创建

它的作用就是，把一个函数的某些参数给固定住
（也就是设置默认值），
返回一个新的函数，调用这个新函数会更简单。

#比较少用

from functools import partial

def func(a,b):
    return a+b
                #不可以给第一个值固定 否则报错
f = partial(func,b = 10)
print(f(20))        #传a的值