python 高阶函数

函数式编程

用一系列函数解决问题

传入参数一定，结果必一定（只有一个输入一个输出）

def myadd(x, y):# 不可重入函数:
    return x + y
y = 200
def myadd2(x):#可重入函数
    return x + y
print(myadd2(10))  # 210
y = 300
print(myadd2(10))  # 310

函数式编程的要求：

　　创建函数最好不要访问局部作用域以外的变量，这样可以保证返回结果的唯一性（可重入性）

高阶函数

满足下面条件之一的为高阶函数：

　　1、函数接受一个或者多个函数作为参数传入

　　2、函数返回一个函数

python内建的高阶函数：

　　map、filter、sorted

map函数

　　第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。

　　格式：

　　　　map(func,iterables1,,iterables2,.........)

　　参数：

function -- 函数，有一个或两个参数
iterable -- 一个或多个序列

　　返回值

Python 2.x 返回列表。
Python 3.x 返回迭代器

def power(x):
    return x**2
# for x in map(power,range(1,10)):
#     print(x)
# for x in map(lambda x :x**2,range(1,10)):
#     print(x)
print(list(map(power,range(1,10))))
#[1, 4, 9, 16, 25, 36, 49, 64, 81]

# 提供了两个列表，对相同位置的列表数据进行相加
print(list(map(lambda x,y:x+y,[1,2,3,4],[4,3,2,1])))
#[5, 5, 5, 5]
#必须要加list，不加list返回的是内存地址
#<map object at 0x0000022754376278>

#求：1 ** 9 + 2 ** 8 + 3 ** 7 + ......9 ** 1
s = 0
for x in map(pow, range(1, 10), range(9, 0, -1)):
    s += x
print(s)

map(function,iterable...)

filter函数

　　函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。

　　该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判，然后返回　True 或 False，最后将返回 True 的元素放到新列表中。

　　语法：

　　　　filter(function,iterable)

　　参数：

　　　　function——判断函数

　　　　iterable——可迭代函数

# def is_odd2(n):
#     if n%2 ==1:
#         return True
#     return False

def is_odd(n):
    return n%2 == 1
#过滤出列表中的所有奇数
list1 = filter(is_odd,[1,2,3,4,5,6,7,8,9,10])
print(list1)#[<filter object at 0x000001D43715A8D0>]   python3返回的是一个filter类，相当于迭代器
list2 = list(filter(is_odd,[1,2,3,4,5,6,7,8,9,10]))
print(list2)
L = [x for x in filter(is_odd,range(1,10))]
print(L)# [1, 3, 5, 7, 9]

filter(function)

def is_prime(x):
    if x <2:
        return False
    for y in range(2,x):#当循环里面所有的值都不能整除x的时候，则返回True
        # if x==y:
        #     continue
        if x%y==0:
            return False
    return True
L2 = [x for x in filter(is_prime,range(20,30))]
print(L2)

fliter(function,iterable)

sorted函数

　　将原可迭代对象的数据进行排序，生成排序后的列表

sort与sorted区别：

　　sort是应用在列表list上的方法，sorted可以对可迭代的对象进行排序操作，list 的 sort 方法返回的是对已经存在的列表进行操作,永久性的修改原始的list,，而内建函数 sorted 方法返回的是一个新的 list，原来的list顺序不变，而不是在原来的基础上进行的操作。

参数：

sorted(iterable,key=None,reverse=False)
iterable:可迭代对象
key:主要用来进行元素比较，指定可迭代对象中的一个元素来进行排序
reverse:排序规则，reverse = True 降序， reverse = False 升序（默认）

返回值：

返回重新排序的列表

利用key进行倒序排序

ex_list = [5,4,7,1,9,3,5,7,0]
re_list = sorted(ex_list,key = lambda x : x*-1,reverse = False)
print(re_list)  
# [9, 7, 7, 5, 5, 4, 3, 1, 0]

利用reverse来对可迭代对象进行倒序排序

re_list = sorted(ex_list,reverse = True)
print(re_list)  
# [9, 7, 7, 5, 5, 4, 3, 1, 0]

按字典的 key值对字典排序

d = {"lilee":25, "wangyan":21, "liqun":32, "lidaming":19}
print(sorted(d.keys()))
# ['lidaming', 'lilee', 'liqun', 'wangyan']

按字典的 value值对字典排序

d = {"lilee":25, "wangyan":21, "liqun":32, "lidaming":19}
print(sorted(d.items(), key=lambda item:item[1]))
# [('lidaming', 19), ('wangyan', 21), ('lilee', 25), ('liqun', 32)]

练习key排序

同时可以利用key的值来进行数组字典的排序

arry = [{"age":20,"name":"a","score":78},
        {"age":18,"name":"b","score":60},
        {"age":23,"name":"c","score":99}]
array = sorted(arry,key = lambda x :x["age"])
print(array)
# [{'age': 18, 'name': 'b', 'score': 60}, 
# {'age': 20, 'name': 'a', 'score': 78}, 
# {'age': 23, 'name': 'c', 'score': 99}]

再次练习用key来对可迭代对象来排序

names = ["Tom","Jerry","Spike","Tyke"]
def fun(x):     #x为可迭代对象中的值，传入了函数
    print("k()传入:",x, "返回去的",x[::-1])
    return x[::-1]  # 逆序
name = sorted(names,key = fun)
# k()传入: Tom 返回去的   moT
# k()传入: Jerry 返回去的 yrreJ
# k()传入: Spike 返回去的 ekipS
# k()传入: Tyke 返回去的  ekyT
print(name) 
# ['Spike', 'Tyke', 'Tom', 'Jerry']

递归函数

　　函数直接或者间接的调用自身

说明：

　　递归一定要控制递归层数，当符合一定条件时要终止递归

　　无return的函数递归，可理解为函数嵌套

无return递归

#函数嵌套  无return
def fx(n):
    print("fx进入第", n, '层')
    if n == 3:
        return
    fx(n + 1)
    print("fx退出第", n, '层')

fx(1)
print("程序结束")

# fx进入第 1 层
# fx进入第 2 层
# fx进入第 3 层
# fx退出第 2 层
# fx退出第 1 层
# 程序结束

有return的递归

#有return
def fx(n):
    print("fx进入第", n, '层')
    if n == 3:
        return
    return fx(n + 1)
    print("fx退出第", n, '层')

fx(1)
print("程序结束"

# fx进入第 1 层
# fx进入第 2 层
# fx进入第 3 层
# 程序结束

递归阶乘

def fac(n):
    # 此函数用递归的方式实现阶乘
    if n == 1:  # 1! 直接返回1
        return 1      #为什么return 1 因为这里return的是fac(n-1)=1
    return n * fac(n - 1)

print(fac(5))  # 120

递归和

def mysum(n):
    if n ==1:
        return 1
    return n + mysum(n-1)   #函数用来递减，加公式
print(mysum(100))

闭包

　　闭包是引用函数外部的变量的函数

　　在本质上，闭包是将内部嵌套函数和函数外部的执行环境绑定在一起的对象

闭包要接收外部函数的参数和内部函数的参数

闭包需要满足三大条件：

　　1，必须有一个内嵌函数

　　2，内部函数需要引用外部函数中的参数

　　3，外部函数返回值必须是内嵌函数

1 调用闭包函数时，
2 x = 闭包(外部参数)，　　#x绑定的是内部函数
3 y = x(内部参数)

求1**2 + 2 ** 2 + 3 ** 2 + .... 100 ** 2

def make_power(y):
    def fn(arg):
        return arg ** y
    return fn


y = make_power(2)  # y绑定的是fn
print('5的平方是:', y(5))  

print(sum(map(lambda x: x ** 2, range(1, 101))))
print(sum(map(make_power(2), range(1, 101))))

f(x) = a**x**2 + b*x + c

def get_fx(a, b, c):
    def fx(x):
        return a * x ** 2 + b * x + c
    return fx

f123 = get_fx(1, 2, 3)
print(f123(20))
print(f123(50))

最强闭包

#f(x) = a*x**2+b*x+c
def hanshu0(a):
    def hanshu1(b):
        def hanshu2(c):
            def hanshu3(x):
                return a*x**2+b*x+c
            return hanshu3
        return hanshu2
    return hanshu1
powx = hanshu0(1)   #a的值
powa = powx(2)
powb = powa(3)
powc = powb(20)
print(powc)