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)
