标签:isa ado 元素 ascii 变量类型 额外 保存 www 原因
很多语言中,都允许把函数本身做为参数,传递给其它参数:即所谓的高阶函数。python中也有类似特性:
一、map/reduce、filter、sorted
def fn_map(x): print("fn_map->", x) return 10 * x L = [3, 4, 6, 8] print(list(map(fn_map, L))) print("\n")
输出:
fn_map-> 3 fn_map-> 4 fn_map-> 6 fn_map-> 8 [30, 40, 60, 80]
结合map,我们再把reduce函数加上(最终效果:将所有元素*10再平方,最终得出 “平方和”的"平方根")
def fn_sqrt(x, y): print("fn_sqrt->", x, ",", y) return math.sqrt(x ** 2 + y ** 2) def fn_map(x): print("fn_map->", x) return 10 * x L = [3, 4, 6, 8] result = reduce(fn_sqrt, map(fn_map, L)) print(result) print("\n") print(math.sqrt((3 * 10) ** 2 + (4 * 10) ** 2 + (6 * 10) ** 2 + (8 * 10) ** 2))
注:要先import math,上面的代码输出如下:
fn_map-> 3 fn_map-> 4 fn_sqrt-> 30 , 40 fn_map-> 6 fn_sqrt-> 50.0 , 60 fn_map-> 8 fn_sqrt-> 78.10249675906654 , 80 111.80339887498948 111.80339887498948
上面这个例子,可能实用性不大,下面给个实用性更强的示例,将每个单词的首字母大写,其它字母变小写。
def normalize(name): return name[:1].upper() + name[1:].lower() L1 = [‘adam‘, ‘LISA‘, ‘barT‘] print(list(map(normalize, L1)))
输出:
1.2 filter
filter跟java8里的stream的filter是类似的,可以实现对集合中的元素,按某种规则进行筛选。
示例1:找出10以内的偶数
result = filter(lambda x: x % 2 == 0, range(1, 11)) print(list(result)) # 上面的写法,等效于下面这个 def even(x): return x % 2 == 0 print(list(filter(even, range(1, 11))))
输出:
[2, 4, 6, 8, 10] [2, 4, 6, 8, 10]
示例2:找出200以内的"回数"(即:从左向右,从右向左,都是一样的数,比如:131, 141)
def is_palindrome1(n): if n < 10: return True s = str(n) for i in range(0, int(len(s) / 2)): if s[i] == s[-i - 1]: return True return False def is_palindrome2(n): s1 = str(n) s2 = list(reversed(s1)) return list(s1) == s2 print(list(filter(is_palindrome1, range(1, 201)))) print(list(filter(is_palindrome2, range(1, 201))))
输出:
[1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 22, 33, 44, 55, 66, 77, 88, 99, 101, 111, 121, 131, 141, 151, 161, 171, 181, 191] [1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 22, 33, 44, 55, 66, 77, 88, 99, 101, 111, 121, 131, 141, 151, 161, 171, 181, 191]
1.3 sorted
python内置的排序函数sorted,支持数字/字母/以及复杂对象排序,默认是从小到大排序,对于复杂对象的排序规则可以开发者自定义。参考下面的示例:
origin = [-1, 3, -5, 2, -4, 6] # 从小到大排序 a = sorted(origin) print(a) # 按abs绝对值,从小大到排序 a = sorted(origin, key=abs) print(a) # 从大到小排序 a = sorted(origin, reverse=True) print(a) origin = ["Xy", "Aa", "Bb", "dd", "cC", "aA", "Zo"] # 按字母ascii值从小到大排序 print(sorted(origin)) # 将字母转大写后的值排序(即:忽略大小写) print(sorted(origin, key=str.upper)) # 将字母转大写后的值倒排序 print(sorted(origin, key=str.upper, reverse=True)) # 复杂对象排序 origin = [(‘Bob‘, 75), (‘Adam‘, 92), (‘Bart‘, 66), (‘Lisa‘, 88)] def by_name(t): return t[0] # 按人名排序 print(sorted(origin, key=by_name)) def by_score(t): return t[1] # 按得分倒排 print(sorted(origin, key=by_score, reverse=True))
输出:
[-5, -4, -1, 2, 3, 6] [-1, 2, 3, -4, -5, 6] [6, 3, 2, -1, -4, -5] [‘Aa‘, ‘Bb‘, ‘Xy‘, ‘Zo‘, ‘aA‘, ‘cC‘, ‘dd‘] [‘Aa‘, ‘aA‘, ‘Bb‘, ‘cC‘, ‘dd‘, ‘Xy‘, ‘Zo‘] [‘Zo‘, ‘Xy‘, ‘dd‘, ‘cC‘, ‘Bb‘, ‘Aa‘, ‘aA‘] [(‘Adam‘, 92), (‘Bart‘, 66), (‘Bob‘, 75), (‘Lisa‘, 88)] [(‘Adam‘, 92), (‘Lisa‘, 88), (‘Bob‘, 75), (‘Bart‘, 66)]
二、延迟计算/闭包
python的函数定义可以嵌套(即:函数内部再定义函数),利用这个特性很容易实现延迟计算:
import time def export1(month): print("export1 month:", month, " doing...") time.sleep(5) print("export1 done!") def export2(month): def do(): print("export2 month:", month, " doing...") time.sleep(5) print("export2 done!") return do export1(10) print("----------------") r2 = export2(10) print(r2) r2()
这里我们模拟一个耗时的导出功能(假设:要求传入月份,然后导出该月的报表数据),export1为常规版本,调用export1就会马上执行。而export2则是返回一个内部函数do(),调用export2后,返回的是一个Function,并没有实际执行(可以理解为: 返回的是业务处理算法,而非处理结果),真正需要结果的时候,再来调用"返回函数"。
上面的代码输出如下:
export1 month: 10 doing... export1 done! ---------------- <function export2.<locals>.do at 0x107a24a60> export2 month: 10 doing... export2 done!
闭包
很多语言都支持闭包特性,python中当然少不了这个,参考下面的示例:
def my_sqrt1(n): r = [] def do(): for i in range(1, n + 1): r.append(i ** 2) return r return do a = my_sqrt1(4) print(type(a)) b = a() print(type(b)) print(b)
输出:
<class ‘function‘> <class ‘list‘> [1, 4, 9, 16]
闭包有一个经典的坑:不要在闭包函数中使用“值会发生变化的变量"(比如:for循环中的变量)。原因是:python中的闭包本质上是是"内部函数"延时计算,如果有循环变量,循环过程中闭包函数并不会执行,等循环结束了,闭包中引用的循环变量其实是循环结束后最终的值。说起来有点绕口,看下面的示例:
def my_sqrt2(n): r = [] for i in range(1, n + 1): def do(): r.append(i ** 2) return r return do a = my_sqrt2(4) print(type(a)) b = a() print(type(b)) print(b)
输出:
<class ‘function‘> <class ‘list‘> [16]
解释一下:调用a = my_sqrt2(4)时,my_sqrt2(4)马上执行完了,这时候里面的fox循环执行完了,最后i的值停在4,然后这个值被封闭在do函数里,并没有马上执行。然后再调用a()时,这时候才真正调用do()函数,此时i值=4,所以最终r[]列表里,就只追回了一个值4*4=16
如果非要使用循环变量,只能想招儿把这个循环变量,也封闭到一个内部函数里,然后再使用,比如下面这样:
def my_sqrt3(n): def f(j): def g(): return j ** 2 return g r = [] for i in range(1, n + 1): r.append(f(i)) return r a = my_sqrt3(4) print(type(a)) for x in a: print(x())
这个例子仔细研究下蛮有意思的,r.append(f(i)),列表里追加的并非计算结果,而是f(j)里返回的函数g,所以a = my_sqrt3(4)这里,a得到的是一个function组成的list,然后list里的每个g函数实例,都封闭了当次循环的变量i,因为闭包的缘故,i值已经被封印在g内部,不管外部的for循环如何变量,都不会影响函数g。
输出如下:
<class ‘list‘> 1 4 9 16
最后再来看一个廖老师教程上的闭包作业题,用闭包的写法写一个计数器:
def create_counter1(): r = [0] def counter(): r[0] += 1 return r[0] return counter count = create_counter1(); print([count(), count(), count()])
输出:
[1, 2, 3]
对于有洁癖的程序员,可能会觉得要额外设置一个只保存1个元素的list,有点浪费。可以换种写法:
def create_counter2(): n = 0 def counter(): nonlocal n n += 1 return n return counter count = create_counter2(); print([count(), count(), count()])
输出:
[1, 2, 3]
注意这里有一个关键字nonlocal,号称是python3新引入的关键字,为的是让闭包的内部函数里面,能读写内部函数外的变量。(但是在第1种写法中,r=[0]不也是定义在外部么?区别就是list是复杂的变量类型,而第2种写法中n是简单类型的变量,做为python初学者,不是很理解这个哲学思想^_~)
参考文档:
1、廖雪峰的python教程:函数式编程
标签:isa ado 元素 ascii 变量类型 额外 保存 www 原因
原文地址:https://www.cnblogs.com/yjmyzz/p/8918925.html