再一次重新学习Python——函数式编程

• 函数式编程

函数式编程的一个特点就是，允许把函数本身作为参数传入另一个函数，还允许返回一个函数！

• 高阶函数

既然变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数就是高阶函数。

• map()和reduce()

map()函数接收两个参数，一个是函数，一个是序列，map将传入的函数一次作用到序列的每个元素，并且把结果作为新的list返回。

比如，把这个list所有数字转为字符串：

>>> map(str, [1, 2, 3, 4, 5, 6, 7, 8, 9])
['1', '2', '3', '4', '5', '6', '7', '8', '9']

 reduce()函数

reduce把一个函数作用在一个序列[x1, x2, x3...]上，这个函数必须接收两个参数，reduce把结果继续和序列的下一个元素做累积计算，其效果就是：

reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)

比方说对一个序列求和，就可以用reduce实现：

>>> def add(x, y):
...     return x + y
...
>>> reduce(add, [1, 3, 5, 7, 9])
25

这个例子本身没多大用处，但是，如果考虑到字符串str也是一个序列，对上面的例子稍加改动，配合map()，我们就可以写出把str转换为int的函数：

>>> def fn(x, y):
...     return x * 10 + y
...
>>> def char2num(s):
...     return {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}[s]
...
>>> reduce(fn, map(char2num, '13579'))
13579

这个函数是完成将字符转换为数字的功能，用到了dict和数组的功能，其中你可以把
{'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}看成是一个字典，s是key，函数通过s参数查找字典中的key，进而获取value，返回value的值。

利用map()函数，把用户输入的不规范的英文名字，变为首字母大写，其他小写的规范名字。输入：['adam', 'LISA', 'barT']，输出：['Adam', 'Lisa', 'Bart']。

def normalize(name):
	name=name[0].upper()+name[1:].lower()
	return name

L1 = ['adam', 'LISA', 'barT']
L2 = list(map(normalize, L1))
print L2

• filter()函数

filter()函数用于过滤序列。和map()类似，filter()也接收一个函数和一个序列。和map()不同的时，filter()把传入的函数依次作用于每个元素，然后根据返回值是True还是False决定保留还是丢弃该元素。

扫描二维码关注公众号，回复： 4663478 查看本文章

把一个序列中的空字符串删掉，可以这么写：

def not_empty(s):
    return s and s.strip()
#strip()可以去除首位的空格
#strip('0')可以去除首位的0

filter(not_empty, ['A', '', 'B', None, 'C', '  '])
# 结果: ['A', 'B', 'C']

练习！！！！！！！！！！！！！！！！！！！！！！！！！！！

用filter()删除1~100的素数。 

import math
L = range(1, 101)
def delprimenum(str):
	if str == 1:
		return str
	for i in range(2,int(math.sqrt(str)+1)):
		if str % 1 == 0:
			return str

print filter(delprimenum, L)

• sorted()函数

Python内置的sorted()函数就可以对list进行排序：

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

 关于sorted函数的参数根据Python官方文档

sorted(iterable[,cmp,[,key[,reverse=True]]])
作用：返回一个经过排序的列表。
第一个参数是一个iterable，返回值是一个对iterable中元素进行排序后的列表(list)。
可选的参数有三个，cmp、key和reverse。
1)cmp指定一个定制的比较函数，这个函数接收两个参数（iterable的元素），如果第一个参数小于第二个参数，返回一个负数；如果第一个参数等于第二个参数，返回零；如果第一个参数大于第二个参数，返回一个正数。默认值为None。
2)key指定一个接收一个参数的函数，这个函数用于从每个元素中提取一个用于比较的关键字。默认值为None。
3)reverse是一个布尔值。如果设置为True，列表元素将被倒序排列。
key参数的值应该是一个函数，这个函数接收一个参数并且返回一个用于比较的关键字。对复杂对象的比较通常是使用对象的切片作为关键字。例如：
students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
sorted(students, key=lambda s: s[2]) #按年龄排序

此外，sorted()函数也是一个高阶函数，它还可以接收一个比较函数来实现自定义的排序。比如，如果要倒序排序，我们就可以自定义一个reversed_cmp函数：

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

传入自定义的比较函数reversed_cmp，就可以实现倒序排序：

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

• 返回函数

函数作为返回值

高阶函数除了可以接受函数作为参数外，还可以把函数作为结果值返回。

我们来实现一个可变参数的求和。通常情况下，求和的函数是这样定义的：

def calc_sum(*args):
    ax = 0
    for n in args:
        ax = ax + n
    return ax

但是，如果不需要立刻求和，而是在后面的代码中，根据需要再计算怎么办？可以不返回求和的结果，而是返回求和的函数！

def lazy_sum(*args):
    def sum():
        ax = 0
        for n in args:
            ax = ax + n
        return ax
    return sum

当我们调用lazy_sum()时，返回的并不是求和结果，而是求和函数：

>>> f = lazy_sum(1, 3, 5, 7, 9)
>>> f
<function sum at 0x10452f668>

调用函数f时，才真正计算求和的结果：

>>> f()
25

在这个例子中，我们在函数lazy_sum中又定义了函数sum，并且，内部函数sum可以引用外部函数lazy_sum的参数和局部变量，当lazy_sum返回函数sum时，相关参数和变量都保存在返回的函数中，这种称为“闭包（Closure）”的程序结构拥有极大的威力。

请再注意一点，当我们调用lazy_sum()时，每次调用都会返回一个新的函数，即使传入相同的参数：

>>> f1 = lazy_sum(1, 3, 5, 7, 9)
>>> f2 = lazy_sum(1, 3, 5, 7, 9)
>>> f1==f2
False

f1()和f2()的调用结果互不影响。

关于闭包查看博客返回函数一章

返回闭包时牢记的一点就是：返回函数不要引用任何循环变量，或者后续会发生变化的变量。

• 匿名函数

关键字lambda表示匿名函数，冒号前的x，y表示函数参数，例如

lambda x: x * x实际上就是

def f(x):

      return x*x

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

• 装饰器

在代码运行期间动态增加功能的方式，称之为“装饰器”（Decorator）。接受函数作为参数并返回一个函数。

关于@

@修饰符 
　　‘@’符号用作函数修饰符是python2.4新增加的功能，修饰符必须出现在函数定义前一行，不允许和函数定义在同一行。也就是说＠A def f(): 是非法的。 只可以在模块或类定义层内对函数进行修饰，不允许修修饰一个类。一个修饰符就是一个函数，它将被修饰的函数做为参数，并返回修饰后的同名函数或其它可调用的东西。

　　本质上讲，装饰符@类似于回调函数，把其它的函数（暂且称为目的参数）作为自己的入参，在目的函数执行前，执行一些自己的操作，比如：计数、打印一些提示信息等，然后返回目的函数。下面列举一个简单的例子。

import time

def time(func):
    print(time.ctime())
    return func()

@time  # 从这里可以看出@time 等价于 time(xxx()),但是这种写法你得考虑python代码的执行顺序
def xxx():
    print('Hello world!')

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9

运行结果：
Wed Jul 26 23:01:21 2017
Hello world!

练习！！！！！！！！！！！！！！！！！！！！！！！

1、编写一个decorator，能在函数调用的前后打印出'begin call'和'end call'的日志。

def log(func):
	def wrapper():
		print 'begin call'
		func()
		print 'end call'
	return wrapper

@log
def myage():
	print '21'

myage()

2、再思考一下能否写出一个@log的decorator，使它既支持：

@log
def f():
    pass

又支持：

@log('execute')
def f():
    pass

代码！！！！！关于decorator需要好好看看 

import functools

def log(arg):
	if callable(arg):
		# @log模式
		func = arg
		@functools.wraps(func)
		def wrapper(*args, **kw):
			print 'call %s(): ' %func.__name__
			func(*args, **kw) #相当于返回func
		return wrapper
	else:
		# @log('arg')模式
		def decorator(func):
			def wrapper(*args, **kw):
				print '%s %s(): ' %(arg, func.__name__)
				func(*args, **kw)
			return wrapper
		return decorator

@log
def now():
	print 'Saikikky'

@log('Hi')
def next():
	print 'Saikikky'


now()
next()

•  偏函数

简单总结functools.partial的作用就是，把一个函数的某些参数给固定住（也就是设置默认值），返回一个新的函数，调用这个新函数会更简单。