python函数式编程

1, lambda

lambda可以创建匿名函数,一个完整的lambda表达式格式如下:

lambda [arg1[, arg2, ... argN]]: 返回值

lambda表达式返回一个可调用的函数对象。

>>> func = lambda x:x*2
>>> func
<function <lambda> at 0x01E2E130>
>>> func(3)
6

有默认参数的lambda表达式:

>>> func = lambda a,b = 2: a + b
>>> func(1)
3
>>> func(1,3)
4

变长参数的lambda表达式:

>>> func = lambda *a: [it * 2 for it in a]
>>> func(1,3)
[2, 6]

2.filter

filter用法如下:

filter(func, seq)

bool 函数func作用于seq序列中的每一个元素,返回一个使func为True的的序列

>>> func = lambda a: a%2
>>> filter(None,(1,2,3,4))
(1, 2, 3, 4)
>>> filter(func,(1,2,3,4))
(1, 3)

3.map

map的用法如下:

map(func, seq1[,seq2...])

map将函数func作用于seq序列的每个元素上,返回一个func函数返回值的列表。

>>> func = lambda a: a*2
>>> map(func, (1,2, 3))
[2, 4, 6]
>>> map(None, (1,2, 3))
[1, 2, 3]

map参数有多个序列时,依次取出各个序列的第i个元素,组成元组,func作用于该元组,返回func返回值的列表。

>>> map(lambda a, b: a+b, (1,2,3), (1,1,1))
[2, 3, 4]

4.reduce

reduce的用法如下:

reduce(func, seq)

reduce将二元函数func作用于seq序列,首先func作用于的序列的前两个元素,得到func的返回值和第三个元素再被func作用,直到完成整个序列。

>>> reduce(lambda a, b: a+b, (1,2,3))
6

5.sorted

>>> help(sorted)

Help on built-in function sorted in module __builtin__:

sorted(...)

    sorted(iterable, cmp=None, key=None, reverse=False) --> new sorted list

传入可迭代对象,返回一个新的排序后的列表,返回的是新对象。

cmp是用于比较的函数,根据key参数进行比较,key是cmp比较的对象,reverse是是否逆序。使用key比使用cmp效率高。

>>> ll = [(1,2), (5,6), (3,4)]

>>> sorted(ll, lambda x,y:cmp(sum(x),sum(y)))

[(1, 2), (3, 4), (5, 6)]

>>> sorted(ll, key=lambda s:sum(s))

[(1, 2), (3, 4), (5, 6)]

忽略大小写的字符串的列表排序:

>>> def cmp_ignore_case(s1, s2):

        return cmp(s1.upper(), s2.upper())

>>> ls = ['Ab', 'aa']

>>> sorted(ls, cmp = cmp_ignore_case)

['aa', 'Ab']

>>> sorted(ls)

['Ab', 'aa']

list对象有自己的排序函数,用法同sorted差不多,排序后的对象仍是原来的对象。

>>> help(list.sort)

Help on method_descriptor:


sort(...)

    L.sort(cmp=None, key=None, reverse=False) -- stable sort *IN PLACE*;

    cmp(x, y) -> -1, 0, 1

5.偏函数

比如add(a,b) 函数,大量情况下,a=1,会有很多add(1,x)的调用,每次传入参数1,很麻烦,如何简化呢,这就是偏函数的功能。python通过functools.partial模块实现。

>>> from operator import add
>>> add1 = partial(add, 1)
>>> add1(1)
2

6.闭包

函数嵌套中,内部函数中引用了外部函数内定义的局部变量,并且外部函数返回了内部函数的引用,那么内部函数就成了闭包。闭包的__closure__属性保存了外部函数中的变量。

>>> def func():
	a,b = 1,2
	def clo(x):
	    print locals()
	    return x*a,x*b
	return clo
>>> a = func()
>>> a.__closure__[0].cell_contents
1
>>> a.__closure__[1].cell_contents
2

看另一个例子:

def counter(start_at=0):   
    count = [start_at]   
    def incr():  
        count[0] += 1  
        return count[0]  
    return incr 
>>> clo = counter(5)
>>> clo()
6
>>> clo()
7


你可能感兴趣的:(python函数式编程)