Python入门：zip、lambda、filter、map、reduce

• zip()

用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。

如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。

a = [1,2,3]
b = [4,5,6]
c = [4,5,6,7,8]
zipped = zip(a,b)     # 打包为元组的列表
print(zipped)
# [(1, 4), (2, 5), (3, 6)]

print(zip(a,c))              # 元素个数与最短的列表一致
# [(1, 4), (2, 5), (3, 6)]

print(zip(*zipped))          # 与 zip 相反，*zipped 可理解为解压，返回二维矩阵式
# [(1, 2, 3), (4, 5, 6)]

• lambda

实现单行最小函数

g = lambda x: x * 2 
#相当于
def g(x):
    return x*2

convolve = lambda i, k: tf.nn.conv2d(i, k,
                                         strides=[1, stride_y, stride_x, 1],
                                         padding=padding)
.
.
.
output_groups = [convolve(i, k) for i, k in zip(input_groups, weight_groups)]

• filter(function, sequence)

对sequence中的item依次执行function(item)，将执行结果为True的item组成一个List/String/Tuple（取决于sequence的类型）。其中function可以为None，但function的参数必须是一个。

def func(a):
    if a > 0:
        return a

if __name__ == '__main__':
    a = filter(None, range(-5, 5))
    print(a, list(a))
    # <filter object at 0x0000000003CD32E8> [-5, -4, -3, -2, -1, 1, 2, 3, 4]
    aa = filter((lambda x: x > 0), range(-5, 5))
    print(aa, list(aa))
    # <filter object at 0x0000000003CADC88> [1, 2, 3, 4]
    aaa = filter(func, [1, -1, 2, 3, -4])
    print(aaa, list(aaa))
    # <filter object at 0x0000000003D7F0F0> [1, 2, 3]

• map(function, sequence[, sequence, ...])

对sequence中的item依次执行function(item)，将执行结果function(item)组成一个List返回。

if __name__ == '__main__':
    a = map(lambda x: x + 2, [1, 2, 3])
    print(a, list(a))
    # <map object at 0x0000000003CE3208> [3, 4, 5]
    aa = map(pow, [1, 2, 3], [2, 3, 4])
    print(aa, list(aa))
    # <map object at 0x0000000003CBDC50> [1, 8, 81]

• reduce(function, sequence[, starting_value])

对sequence中的item顺序迭代调用function，如果有starting_value，还可以作为初始值调用。function接收的参数个数只能为2，先把sequence中第一个值和第二个值当参数传给function，再把function的返回值和第三个值当参数传给function，然后只返回一个结果。

import functools
if __name__ == '__main__':
    a = functools.reduce(lambda x, y: x + y, [1, 2, 3, 4])
    print(a) # 10
    aa = functools.reduce(lambda x, y: x + y, [1, 2, 3, 4], 10)
    print(aa) # 20
    aaa = functools.reduce(lambda x, y: x * y, [1, 2, 3, 4])
    print(aaa) # 24

等价于：

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