很多语言中,都允许把函数本身做为参数,传递给其它参数:即所谓的高阶函数。python中也有类似特性:

一、map/reduce、filter、sorted

hadoop里的map-reduce思想在python里已经变成内置函数了。map是将某个函数逐一作用于列表中的每个元素。reduce则先从列表中取头2个元素,传到指定函数,然后将计算结果与余下元素依次重复,直到List处理完。
 
1.1 map示例:(将List中的所有元素*10)
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)))

输出:

['Adam', 'Lisa', 'Bart']

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初学者,不是很理解这个哲学思想^_~)

三、aop/装饰器

aop是java生态体系中的精髓之一,而python里同样能做到,而且看上去更简洁。

比如有一个加法函数:

def add1(i, j):
return i + j  

想在add1调用时,自动把入参,返回结果,以及执行时间都记录下来,可以这么做,再定义一个log函数(类似java中的aspect切面定义)

import time

def log(fn):
def do(*args, **kw):
start = time.time()
result = fn(*args, **kw)
end = time.time()
print("function=>", fn.__name__, ",args1=>", args, ",args2=>", kw, ",result=>", result, ",exec_time=>",
(end - start) * 1000, "ms")
return result return do  

然后在add1函数上加上这个"注解"就可以了

@log
def add1(i, j):
return i + j print(add1(1, 2))

输出:

function=> add1 ,args1=> (1, 2) ,args2=> {} ,result=> 3 ,exec_time=> 0.0030994415283203125 ms
3

如果aop本身的"切面"也需要传参数进来,比如:在日志前想附加一段特定的前缀,可以参考下面这样:

import time

def log(fn):
def do(*args, **kw):
start = time.time()
result = fn(*args, **kw)
end = time.time()
print("function=>", fn.__name__, ",args1=>", args, ",args2=>", kw, ",result=>", result, ",exec_time=>",
(end - start) * 1000, "ms")
return result return do def log2(log_prefix):
def around(fn):
def do(*args, **kw):
start = time.time()
result = fn(*args, **kw)
end = time.time()
print(log_prefix, ",function=>", fn.__name__, ",args1=>", args,
",args2=>", kw, ",result=>", result, ",exec_time=>",
(end - start) * 1000, "ms")
return result return do return around @log2("调用日志:")
@log
def add2(i, j):
time.sleep(1)
return i + j print(add2(1, 2))

输出:

function=> add2 ,args1=> (1, 2) ,args2=> {} ,result=> 3 ,exec_time=> 1000.8599758148193 ms
调用日志: ,function=> do ,args1=> (1, 2) ,args2=> {} ,result=> 3 ,exec_time=> 1001.0490417480469 ms
3

注:这里我们刻意把log,log2同时运用在add2上,从输出上看,二个aspect都起作用了。

四、偏函数

还是拿add(i,j) 这个来说事儿吧,如果我们经常会遇到一个场景:想让某个数字固定+10,在其它语言里,通常是再定义一个类似add_10(i)的重载版本(java/c#都是这么干的),但是对于python来说,可以更优雅:

import functools

def add(i, j):
return i + j # 偏函数
add_10 = functools.partial(add, j=10) print(add(1, 2))
print(add_10(1))

输出:

3
11

这种把参数列表中的某些常用项固定,然后再生成一个别名函数的玩法,就称为偏函数

参考文档:

1、廖雪峰的python教程:函数式编程

python:函数的高级特性的更多相关文章

  1. Python:笔记(4)——高级特性

    Python:笔记(4)——高级特性 切片 取一个list或tuple的部分元素是非常常见的操作.Python提供了切片操作符,来完成部分元素的选取 除了上例简单的下标范围取元素外,Python还支持 ...

  2. Python的一些高级特性

    内容基本上来自于廖雪峰老师的blog相当于自己手打了一遍,加强加强理解吧. http://www.liaoxuefeng.com/wiki/001374738125095c955c1e6d8bb493 ...

  3. C++复习11.函数的高级特性

    C++ 函数的高级特性 20131002 C++函数增加了重载(override), inline, const, virtual四种机制,重载和内联机制既可以用于全局函数,也可以用于类的成员函数.c ...

  4. Python面向对象编程高级特性

    ***这里还是根据网上资料,主要是廖雪峰老师的教程学习的笔记,主要介绍python面向对象的高级特性,笔记不全,只是记录自己觉得容易出错的地方*** 1.python作为一种动态语言,他的动态绑定机制 ...

  5. Python序列函数、高级特性及高阶函数

    序列函数: enumerate: for循环时记录索引,逐个返回元组(i, item) sorted:返回新的有序列表 zip:压缩将多个序列的对应位置的元素组成元组 zip(*元组列表): 解压缩 ...

  6. Python的一些高级特性以及反序列化漏洞

    0x01 简述 文章主要记录一下python高级特性以及安全相关的问题 python作为脚本语言,其作为高级语言是由c语言开发的,关于python的编译和链接可以看向这里https://github. ...

  7. 002-python函数、高级特性

    1.函数 1.1 定义函数 在Python中,定义一个函数要使用def语句,依次写出函数名.括号.括号中的参数和冒号:,然后,在缩进块中编写函数体,函数的返回值用return语句返回 自定义一个求绝对 ...

  8. python 9学习 高级特性

    高级特性 掌握了Python的数据类型.  语句      和函数,基本上就可以编写出很多有用的程序了. 比如构造一个1, 3, 5, 7, ..., 99的列表,可以通过循环实现: L = [] n ...

  9. Python中的高级特性

    1.切片.使用“[”和“]”即可,类似Matlab,可以切list,tuple,字符串等. 2.迭代.Python内置的enumerate函数可以把一个list变成索引-元素对. 3.列表生成式.列表 ...

随机推荐

  1. laravel console - 自定义命令

    在改造一个支付流程,新的流程加入了一个新的数据表字段,但是这个新的字段需要通过计算来填充,所以为了兼容历史数据,必须将已有的数据行重新计算一遍该字段. 这时使用 laravel console 命令就 ...

  2. cf1104d二分+数学

    #include<bits/stdc++.h> using namespace std; bool ask(int x,int y){ printf("? %d %d\n&quo ...

  3. CF 449D 题解(状压+容斥)

    状压妙啊... 本题的主体思路:状压+容斥原理(或状压+数位dp) 记g[i]表示按位与后结果所有位上至少有i个1的方案数 那么根据容斥原理,ans=g[0]-g[1]+g[2]-g[3]+g[4]. ...

  4. Math 对象

    Math对象提供了,我们一般进行数学运算的所有函数. Math.random() 随机0~1之间的随机数 [0, 1) Math.max() 求传入参数的最大数 Math.min() 求传入参数的最小 ...

  5. Java获取当前时间的年月日方法

    package com.ob; import java.text.ParseException; import java.text.SimpleDateFormat; import java.util ...

  6. scanf的一个问题(暂未解决)

    如下代码,没有按照预想的那样运行: int a; char b; printf("input a integer\n"); scanf("%d", &a ...

  7. tomcat常用的配置

    这里我们使用tomcat版本:apache-tomcat-7.0.77-windows-x64.zip 为例:下载链接地址为:https://archive.apache.org/dist/tomca ...

  8. python全栈开发day38-css三种引入方式、基础选择器、高级选择器、补充选择器

    一.昨日内容回顾 div:分割整个网站,很多块 (1)排版标签 (2)块级标签 独占一行 可以设置高和宽,如果不设置宽高,默认是父盒子的宽 span: (1) 小区域 (2)文本标签 (3)在一行内显 ...

  9. HTML页面滚动时获取离页面顶部的距离2种实现方法

    获取离滚动页面的顶部距离有两种方法一是DOM:而是jquery,具体的实现如下,感兴趣的朋友可以尝试操作下     方法一:DOM 复制代码 代码如下: <script> window.o ...

  10. BZOJ1819 [JSOI]Word Query电子字典 Trie

    欢迎访问~原文出处——博客园-zhouzhendong 去博客园看该题解 题目传送门 - BZOJ1819 题意概括 字符串a与字符串b的编辑距离是指:允许对a或b串进行下列“编辑”操作,将a变为b或 ...