python的map，reduce和zip


map函数的官方解释：
map(function, iterable, ...)
Return an iterator that applies function to
every item of iterable, yielding the results. If additional iterable arguments
are passed, function must
take that many arguments and is applied to the items from all iterables in parallel. With multiple iterables, the iterator stops when the shortest iterable is exhausted. For cases where the function inputs are already arranged into argument tuples, see itertools.starmap()
      以上是官方给出的解释，将函数function应用到iterable的每一个元素，返回一个iterator。
如果再输入一个iterable2的话，同样将函数应用到iterable2的每一个元素，但是函数function必须要能接受对应的参数。如果是多重迭代（比如：二维数组）map会在最短的那个iterable迭代完结束。
这是一个iterable的例子：



这是两个iterable的例子：



注：其中函数function必须能够接受后面两个数组的参数。
reduce函数的官方解释：
python3之后，reduce函数被移到了functools里。如果直接使用会出现下图错误。



必须导进functools包，如下：



注：python2依然可以直接使用reduce函数 
functools.reduce(function, iterable[, initializer])
Apply function of
two arguments cumulatively to the items of sequence, from left to right,
so as to reduce the sequence to a single value. For example, reduce(lambda x, y: x+y, [1, 2, 3, 4, 5]) calculates ((((1+2)+3)+4)+5).
The left argument, x, is the accumulated value and the right argument, y,
is the update value from the sequence. If the optional initializer is
present, it is placed before the items of the sequence in the calculation, and serves as a default when the sequence is empty. If initializer is
not given and sequence contains
only one item, the first item is returned.
Roughly equivalent to:

defreduce(function, iterable, initializer=None):
    it=
iter(iterable)
    ifinitializer
is
None:
  
     value=
next(it)
    else:
  
     value=
initializer
    forelement
in
it:
        value=
function(value, element)
    returnvalue

看完这段reduce函数的定义就会非常明白了，看看怎么用：



当有initializer参数时：



为什么要先说map和reduce呐？因为map-reduce的名气可是非常的大，起源于谷歌的几篇论文，主要应用在并行计算中，他们对应的中文名叫Map（映射）和reduce（规约）。我当年玩Hadoop时候，在其框架下编程，可没少被他俩折磨。想再了解他们的爱恨情仇的可以看一下他们的故事。
zip的官方定义：
zip(*iterables)
Make an iterator that aggregates elements from each of the iterables.
Returns an iterator of tuples, where the i-th
tuple contains the i-th element from each of the argument sequences or iterables.
The iterator stops when the shortest input iterable is exhausted. With a single iterable argument, it returns an iterator of 1-tuples. With no arguments, it returns an empty iterator. Equivalent to:

defzip(*iterables):
# zip('ABCD', 'xy') --> Ax By
    sentinel=
object()
    iterators=
[iter(it)for
it
initerables]
    whileiterators:
        result=
[]
        forit
in
iterators:
            elem=
next(it, sentinel)
            ifelem
is
sentinel:
              
 return
            result.append(elem)
    yieldtuple(result)

The left-to-right evaluation order of the iterables is guaranteed. This makes possible an idiom for clustering a data series into n-length groups
using zip(*[iter(s)]*n).
This repeats the same iterator n times
so that each output tuple has the result of n calls
to the iterator. This has the effect of dividing the input into n-length chunks.
zip() should
only be used with unequal length inputs when you don’t care about trailing, unmatched values from the longer iterables. If those values are important, use itertools.zip_longest() instead.
zip() in
conjunction with the * operator
can be used to unzip a list:

>>>

>>> x =[1,
2, 3]
>>> y =[4,
5, 6]
>>> zipped = zip(x,y)
>>> list(zipped)[(1, 4), (2, 5), (3, 6)]
>>> x2,y2 =
zip(*zip(x,y))
>>> x ==list(x2)and
y == list(y2)
True

zip的解释就不累述了，理解这个函数的方法和reduce类似。我们看一个小例子。



通过使用map和zip结合，可以完成矩阵的转置，当然使用numpy也可以完成，不过这种写代码的方法也是很常用的。