python 几个重要函数

一、匿名函数lambda

原型：lambda<参数>：函数体，隐函数，定义一些简单的操作，

lambda argument1, argument2,...,argumentN: expression using arguments

1、lambda是一个表达式，而不是一个语句。

因为这一点，lambda可以出现在python语法不允许def出现的地方---例如，在一个列表常量中或者函数调用的参数中，此外，作为一个表达式，lambda返回一个值（一个新函数），可以选择性地赋值给一个变量名。相反，def语句总是得在头部将一个新的函数赋值给一个变量名，而不是将这个函数作为结果返回。

2、lambda的主体是一个单个的表达式，而不是一个代码块。

lambda是一个为编写简单的函数设计的，而def用来处理更大的任务。

3、lambda表达式是起到一个函数速写的作用。允许在代码内嵌入一个函数的定义。

例1：定义一个lambda表达式，求三个数的和

# -*- coding: UTF-8 -*-
f = lambda x,y,z:x+y+z
print f(1,2,3)
print f(4,5,6)

6

15

例2：

>>> x=(lambda a="fee", b="fie", c ="foe": a+b+c)
>>> x("wee")

'weefiefoe'

例3：用lambda表达式求n的阶乘

# -*- coding: UTF-8 -*-
n = 5 
print reduce(lambda x,y:x*y,range(1,n+1))

120

例4：lambda表达式也可以用在def函数中

# -*- coding: UTF-8 -*-
def action(x):
      return lambda y:x+y
a = action(2)
print a(22)

24

这里定义了一个action函数，返回了一个lambda表达式。其中lambda表达式获取了到了上层def作用域的变量名x的值。

a是action函数的返回值，a(22)，即是调用了action返回的lambda表达式。

这里也可以把def直接写成lambda形式。如下：

# -*- coding:UTF-8 -*-

b = lambda x:lambda y:x+y
a = b(3)
print a(2)
print (b(2))(2)

5

4

例5 ：通常用lambda来编写跳转表，如下：

>>> L = [lambda x:x**2, lambda x:x**3, lambda x:x**4]
>>> for f in L:
        print(f(2))

4

8

16

>>> print(L[0](3))

9

二、Map函数

原型：map(function，sequence)，作用是将一个列表映射到另一个列表
map(function,sequence,[sequence,...])->iterator

通过定义可以看到，这个函数的第一个参数是一个函数，剩下的参数是一个或多个序列，返回值是一个迭代器。
function可以理解为是一个一对一或多对一函数，map的作用是以参数序列中的每一个元素调用function函数，返回包含每次function函数返回值的迭代器。

返回可迭代对象，需要list调用来显示所有结果。

>>> list(map(lambda x:x+2,[1,2,3]))

[3,4,5]

>>> list(map(pow,[1,2,3],[2,3,4]))

[1,8,81]

注：pow()函数： 返回x的y次方的值。

>>> def add(x,y): return x+y
>>> map(add, range(8),range(8))

[0,2,4,6,8,10,12,14]

三、filter函数

filter函数会对指定序列执行过滤操作

filter函数的定义：

filter(functon or None, sequence) ->iterator

filter函数会对序列参数sequence中的每个元素调用function函数，最后返回的结果包含调用结果为True的元素。

返回课迭代对象，需要用list调用来显示所有结果。

>>> list(filter((lambda x: x>0), range(-5,5)))

[1,2,3,4]

>>> list(fliter(None,range(-5,5)))

[-5,-4,-3,-2,-1,1,2,3,4]

注：若function为None，则会返回包含非空元素的迭代器。

>>> def f(x): return x % 2 != 0 and x % 3 != 0
>>>  filter(f, range(2,25))

[5,7,11,13,17,19,23]

四、reduce函数

reduce函数，reduce函数会对参数序列中元素进行累积。

reduce函数的定义：

functools.reduce(function, iterable, [initializer])  #python3中reduce是在functools模块中

function参数是一个有两个参数的函数，reduce依次从iterable中取一个元素，和上一次调用function的结果做参数再次调用function。

第一次调用function时，如果提供initial参数，会以iterable中的第一个元素和initial作为参数调用function，否则会以iterable中的前两个元素做参数调用function。

等价于：

def reduce(function,iterable,initializer=None):
it = iter(iterable)
   if initializer is None:
        value = next(it)
   else:
        value = initializer
    for element in it:
        value = function(value,element)
return value

>>> import functools

>>> functools.reduce(lambda x,y:x+y,[1,2,3,4])

10

>>> functools.reduce(lambda x,y:x+y,[1,2,3,4],10)

20

>>> functools.reduce(lambda x,y,x*y,[1,2,3,4])

24

如果没有initial参数，这么算：（（（1+2）+3）+4）

如果有initial参数，这么算：（（（（10 +1）+2）+3）+4）

注意：function函数不能为None，function必须是有2个参数的函数。

五、zip函数

其中sorted()和zip()返回一个序列（列表）对象，reversed()、enumerate()返回一个迭代器（类似序列）

定义：zip([seql,...])接受一系列可迭代对象作为参数，将对象中对应的元素打包成一个个tuple，然后返回由这些tuples组成的list。若传入参数的长度不相等，则返回list的长度和参数中长度最短的对象相同。

>>> list(zip([1,23,3],[213,45,2])) #两个列表长度一致

[(1,213),(23,45),(3,2)]

>>> list(zip([1,23,3],[213,45,2,34,54])) #两个列表长度不一致，以短的为准

[(1,213),(23,45),(3,2)]

zip一些应用：

>>> [[i for i in range(3*n+1,3*n+4)] for n in range(3)]
[[1,2,3],[4,5,6],[7,8,9]]





1、二维矩阵变换（矩阵的行列互换）


>>> a = [[1,2,3],[4,5,6],[7,8,9]]
>>> [[row[col] for row in a] for col in range(len(a[0]))]
[[1,4,7],[2,5,8],[3,6,9]]
>>> list(zip(*a))
[[1,4,7],[2,5,8],[3,6,9]]
>>> map(list,zip(*a))
[[1,4,7],[2,5,8],[3,6,9]]








2、*操作符与zip函数配合可以实现与zip相反的功能，即将合并的序列拆成多个tuple


>>> x=[1,2,3] , y=['a','b','c']
>>> zip(*zip(x,y))
[(1,2,3),('a','b','c')]





3、使用zip合并相邻的列表项





>>> a = [1,2,3,4,5,6]
>>> list(zip(*([iter(a)] * 2)))
[(1,2),(3,4),(5,6)]

>>> group_adjacent = lambda a,k:zip(*([iter(a)] * k))
>>> list(group_adjacent(a,3))
[(1,2,3),(4,5,6)]
>>> list(group_adjacent(a,2))
[(1,2),(3,4),(5,6)]
>>> list(group_adjacent(a,1))
[(1,),(2,),(3,),(4,),(5,),(6,)]






>>> list(zip(a[::2],a[1::2]))
[(1,2),(3,4),(5,6)]






>>> list(zip(a[::3], a[1::3], a[2::3]))
[(1,2,3),(4,5,6)]





>>> group_adjacent = lambda a, k: zip(*(a[i::k] for i in range(k)))
>>> list(group_adjacent(a,3))
[(1,2,3),(4,5,6)]
>>> list(group_adjacent(a,2))
[(1,2),(3,4),(5,6)]
>>> list(group_adjacent(a,1))
[(1,),(2,),(3,),(4,),(5,),(6,)]

    
    

     
     


    
    










4、使用zip和iterator生成滑动窗口(n-grams)


>>> from itertools import islice
>>> def n_grams(a,n):
z = (islice(a,i,None) for i in range(n))
return zip(*z)
>>> a = [1,2,3,4,5,6]
>>> list(n_grams(a,3))
[(1,2,3),(2,3,4),(3,4,5),(4,5,6)]
>>> list(n_grams(a,2))
[(1,2),(2,3),(3,4),(4,5),(5,6)]
>>> list(n_grams(a,4))
[(1,2,3,4),(2,3,4,5),(3,4,5,6)]








5、使用zip反转字典



>>> m = {'a':1, 'b':2, 'c':3, 'd':4}
>>> list(m,items())
[('a',1),('b',2),('c',3),('d',4)]
>>> list(zip(m.values(), m.keys()))
[(1,'a'),(3,'c'),(2,'b'),(4,'d')]
>>> dict(zip(m.values(),m.keys()))
{1:'a',2:'b',3:'c',4:'d'}


      
      

       
       


      
      










参考文献：https://www.cnblogs.com/MrFiona/p/5958916.html