python基础语法_9-2函数式编程

https://www.imooc.com/learn/317

大纲

• 1-函数式编程简介
• 2-高阶函数
• 3-把函数作为参数
• 4-map()函数
• 5-reduce()函数
• 6-filter()函数
• 7-自定义排序函数
• 8-返回函数
• 9-闭包
• 10-匿名函数
• 11-decorator装饰器
• 12-编写无参数decorator
• 13-编写带参数decorator
• 14-完善decorator
• 15-偏函数

 

 

正文

1-函数式编程简介

 

 

 

 

2-高阶函数

 

变量可以指向函数，并且可以直接对变量进行调用

例子：

# abs 求绝对值的函数

f = abs # 变量f指向函数

f(-20) # 直接调用函数

函数名是指向函数的变量

例子：abs 赋值新的函数，此时abs为len函数，当再想以前一样使用则报错

 

 

 

3-python把函数作为参数

 

4-map()函数

https://www.imooc.com/code/6049

map()是 Python 内置的高阶函数，它接收一个函数 f 和一个 list，并通过把函数 f 依次作用在 list 的每个元素上，得到一个新的 list 并返回。

注意：map()函数不改变原有的 list，而是返回一个新的 list。

利用map()函数，可以把一个 list 转换为另一个 list，只需要传入转换函数。

由于list包含的元素可以是任何类型，因此，map() 不仅仅可以处理只包含数值的 list，事实上它可以处理包含任意类型的 list，只要传入的函数f可以处理这种数据类型。

 

5-reduce()函数

https://www.imooc.com/code/6050

reduce()函数也是Python内置的一个高阶函数。reduce()函数接收的参数和 map()类似，一个函数 f，一个list，但行为和 map()不同，reduce()传入的函数 f 必须接收两个参数，reduce()对list的每个元素反复调用函数f，并返回最终结果值。

例如，编写一个f函数，接收x和y，返回x和y的和：

def f(x, y): return x + y

调用 reduce(f, [1, 3, 5, 7, 9])时，reduce函数将做如下计算：

先计算头两个元素：f(1, 3)，结果为4； 再把结果和第3个元素计算：f(4, 5)，结果为9； 再把结果和第4个元素计算：f(9, 7)，结果为16； 再把结果和第5个元素计算：f(16, 9)，结果为25； 由于没有更多的元素了，计算结束，返回结果25。

上述计算实际上是对 list 的所有元素求和。虽然Python内置了求和函数sum()，但是，利用reduce()求和也很简单。

reduce()还可以接收第3个可选参数，作为计算的初始值。如果把初始值设为100，计算：

reduce(f, [1, 3, 5, 7, 9], 100)

结果将变为125，因为第一轮计算是：

计算初始值和第一个元素：f(100, 1)，结果为101。

 

6-filter()函数

https://www.imooc.com/code/6051

ilter()函数是 Python 内置的另一个有用的高阶函数，filter()函数接收一个函数 f 和一个list，这个函数 f 的作用是对每个元素进行判断，返回 True或 False，filter()根据判断结果自动过滤掉不符合条件的元素，返回由符合条件元素组成的新list。

 

s.strip(rm) 删除 s 字符串中开头、结尾处的 rm 序列的字符。

当rm为空时，默认删除空白符（包括'\n', '\r', '\t', ' ')，如下：

a = ' 123' a.strip()

结果： '123'

a='\t\t123\r\n' a.strip()

结果：'123'

 

7-自定义排序函数

https://www.imooc.com/code/6053

sorted()也是一个高阶函数，它可以接收一个比较函数来实现自定义排序，比较函数的定义是，传入两个待比较的元素 x, y，如果 x 应该排在 y 的前面，返回 -1，如果 x 应该排在 y 的后面，返回 1。如果 x 和 y 相等，返回 0。

该方法穿2个参数比较只能在python2中使用

例子：

因此，如果我们要实现倒序排序，只需要编写一个reversed_cmp函数：

def reversed_cmp(x, y): if x > y: return -1 if x < y: return 1 return 0

这样，调用 sorted() 并传入 reversed_cmp 就可以实现倒序排序：

>>> sorted([36, 5, 12, 9, 21], reversed_cmp) [36, 21, 12, 9, 5]

8-返回函数

https://www.imooc.com/code/6054

Python的函数不但可以返回int、str、list、dict等数据类型，还可以返回函数！

例如，定义一个函数 f()，我们让它返回一个函数 g，可以这样写：

def f(): print 'call f()...' # 定义函数g: def g(): print 'call g()...' # 返回函数g: return g

仔细观察上面的函数定义，我们在函数 f 内部又定义了一个函数 g。由于函数 g 也是一个对象，函数名 g 就是指向函数 g 的变量，所以，最外层函数 f 可以返回变量 g，也就是函数 g 本身。

调用函数 f，我们会得到 f 返回的一个函数：

>>> x = f() # 调用f() call f()... >>> x # 变量x是f()返回的函数： <function g at 0x1037bf320> >>> x() # x指向函数，因此可以调用 call g()... # 调用x()就是执行g()函数定义的代码

请注意区分返回函数和返回值：

def myabs(): return abs # 返回函数 def myabs2(x): return abs(x) # 返回函数调用的结果，返回值是一个数值

返回函数可以把一些计算延迟执行。

例如，如果定义一个普通的求和函数：

def calc_sum(lst): return sum(lst)

调用calc_sum()函数时，将立刻计算并得到结果：

>>> calc_sum([1, 2, 3, 4]) 10

但是，如果返回一个函数，就可以“延迟计算”：

def calc_sum(lst): def lazy_sum(): return sum(lst) return lazy_sum

# 调用calc_sum()并没有计算出结果，而是返回函数:

>>> f = calc_sum([1, 2, 3, 4]) >>> f <function lazy_sum at 0x1037bfaa0>

# 对返回的函数进行调用时，才计算出结果:

>>> f() 10

由于可以返回函数，我们在后续代码里就可以决定到底要不要调用该函数。

9-闭包

https://www.imooc.com/code/6059

考察上一小节定义的 calc_sum 函数：

def calc_sum(lst): def lazy_sum(): return sum(lst) return lazy_sum

注意: 发现没法把 lazy_sum 移到 calc_sum 的外部，因为它引用了 calc_sum 的参数 lst。

像这种内层函数引用了外层函数的变量（参数也算变量），然后返回内层函数的情况，称为闭包（Closure）。

闭包的特点是返回的函数还引用了外层函数的局部变量，所以，要正确使用闭包，就要确保引用的局部变量在函数返回后不能变。

 

10-匿名函数

https://www.imooc.com/code/6060

关键字lambda 表示匿名函数，冒号前面的 x 表示函数参数。

匿名函数有个限制，就是只能有一个表达式，不写return，返回值就是该表达式的结果。

使用匿名函数，可以不必定义函数名，直接创建一个函数对象，很多时候可以简化代码：

>>> sorted([1, 3, 9, 5, 0], lambda x,y: -cmp(x,y)) [9, 5, 3, 1, 0]

返回函数的时候，也可以返回匿名函数：

>>> myabs = lambda x: -x if x < 0 else x >>> myabs(-1) 1 >>> myabs(1) 1

11-decorator装饰器

https://www.imooc.com/video/6064

Python的 decorator 本质上就是一个高阶函数，它接收一个函数作为参数，然后，返回一个新函数。

使用 decorator 用Python提供的 @ 语法，这样可以避免手动编写 f = decorate(f) 这样的代码。

装饰器的作用：在新函数中为原函数添加新功能，并将函数返回给原函数

 

 

12-编写无参数decorator

https://www.imooc.com/code/6065

Python的 decorator 本质上就是一个高阶函数，它接收一个函数作为参数，然后，返回一个新函数。

使用 decorator 用Python提供的 @ 语法，这样可以避免手动编写 f = decorate(f) 这样的代码。

 

13-编写带参数decorator

https://www.imooc.com/code/6066

如果有的函数非常重要，希望打印出'[INFO] call xxx()...'，有的函数不太重要，希望打印出'[DEBUG] call xxx()...'，这时，log函数本身就需要传入'INFO'或'DEBUG'这样的参数，类似这样：

@log('DEBUG') def my_func(): pass

把上面的定义翻译成高阶函数的调用，就是：

my_func = log('DEBUG')(my_func)

上面的语句看上去还是比较绕，再展开一下：

log_decorator = log('DEBUG') my_func = log_decorator(my_func)

上面的语句又相当于：

log_decorator = log('DEBUG') @log_decorator def my_func(): pass

所以，带参数的log函数首先返回一个decorator函数，再让这个decorator函数接收my_func并返回新函数：

def log(prefix): def log_decorator(f): def wrapper(*args, **kw): print '[%s] %s()...' % (prefix, f.__name__) return f(*args, **kw) return wrapper return log_decorator @log('DEBUG') def test(): pass print test()

执行结果：

[DEBUG] test()... None

 

14-完善decorator

调用@functools.wraps(f)来将原函数的属性传给新函数

由于decorator返回的新函数函数名已经不是'f2'，而是@log内部定义的'wrapper'。这对于那些依赖函数名的代码就会失效。

 

注意@functools.wraps应该作用在返回的新函数上。

 

15-偏函数

https://www.imooc.com/code/6068

functools.partial就是帮助我们创建一个偏函数的，不需要我们自己定义int2()，可以直接使用下面的代码创建一个新的函数int2：

>>> import functools >>> int2 = functools.partial(int, base=2) >>> int2('1000000') 64 >>> int2('1010101') 85

所以，functools.partial可以把一个参数多的函数变成一个参数少的新函数，少的参数需要在创建时指定默认值，这样，新函数调用的难度就降低了。