apply、map及函数工具、list的再构造

http://hi.baidu.com/peaksst/blog/item/457de91056bfa803213f2e99.html

python（22）: apply、map及函数工具、list的再构造（14.2-14.5）

2007-07-28 16:37

首先来复习python中函数的定义。在python中，有两种方式可以用来定义一个函数。用def可以定义有名字的函数。用lambda可以定义匿名函数。由于在实际调用一个函数时，实参的个数可能是一个也可能是两个，还可能是多个。因此在形参前面加上*或**来处理这个情况。比如：

1. def test(*x):
2.      if len(x)>0:
3.         for c in x:
4.            print c
5.      else:
6.         print None

上面定义的函数的功能是把参数一个一个打出来（通过print），这个函数可以使用没有实参的形式调用，比如：test();也可以使用一个实参的形式调用，比如：test(4);还可以以多个实参的形式调用，比如：test(1,2,3,4)。但不管是哪种方式，在调用的时候实际参数的个数都已经确定下来了，一个就是一个，两个就是两个。现在假设在一个程序中有一个list，比如叫userInput，这个list中的成员是由用户在使用程序时交互确定的，在运行中可能有一个成员，也可能有多个成员，这一切都要看用户怎么操作。现在要用test函数把userInput打出来。那么使用下面这个形式是不行的：

• test(userInput)

这只会把userInput作为一个整体打出来，比如说用户选择后userInput=[1,2]，那么打出来的是[1,2]，而我们想要的结果是：
1
2
这种形式的。很自然的，可能会想到应该用一个for循环：

1. for c in userInput:
2.      test(c)

这当然能实现上面要求的功能。不过，在python中还有更简单的办法，就是使用内置函数apply：

• apply(test, userInput)

表示把userInput作为test的参数，也就是说比如在程序运行时，userInput得到的值是[1,2,3]，那么就相当于test(1,2,3)。如果userInput得到的实际值是[1,2]，那么就相当于test(1,2)。

总之，定义函数时在形式参数面前加上*或**是为了，在调用这个函数的时候可以灵活地提供实参的个数。而apply则是为了可以用不定个数的实际参数来调用函数。有点晕。（我也想不到一个更好的表达方式，或更好的例子。书中说，在后面会看到应用apply强大能力的例子）

其实还可以更简单，连apply都不用，直接写成：

• test(*userInput)

这表示的意思就是apply(test,userInput)。可以把函数定义的中形参前面的*理解为“打包”操作，也就是把多余的实参都打包在一个tuple中;可以把调用时的*理解为“解包”的操作，比如说这里表示：调用test函数，实参是对userInput“解包”后所得的东西。当然对于**也可以以相同的方式理解。在test(**D)的形式中，D必须为一个dictionrary，相当于test(key1=value1,key2=value2...)。
（其实我不知道为什么会在python中出现这种古怪的东西，看这本书的前面几章时，觉得python太棒了，真的是很简洁。不过越往后看，觉得python越来越背离了它“简单”的宗旨）

map函数在前面介绍过了，基本的形式是：

• map(function, seq1,seq2...)

map实际上是python中一大类函数的一个代表，这类函数可以被称为函数工具。常用的函数中，同类的还有filter和reduce。先来看filter：

• filter(func or None,seq)

它返回一个序列类型的值。表示把seq中的每个成员依次代入function中，如果为真则它将成为返回序列中的一个成员。filter函数类似于：

1. res = list()
2. for x in seq:
3.      if func(x):
4.         res.append(x)
5. res

如果filter的第一个实参为None，则表示把seq的中真值挑出来。

再来看reduce函数：

• reduce(function, sequence[, initial])

表示把sequence按照function提供的规则进行计算，最后算出一个值来。这个function必须具有两个参数，比如：

1. L = [1,2,3,4,5]
2. reduce((lambda x,y: x*y),L) ===> 120

这就相当于把乘法应用于L的各个成员中，也就是1*2*3*4*5。reduce的第三个参数表示一个初始值。即初始值*1*2*3*4*5。python中有一个叫operator的模块，其中提供了很多操作，比如加法叫add，乘法叫mul。上面的这一小段代码可以写成：

1. import operator
2. L = range(6)[1:]
3. reduce(operator.mul, L)

从上面介绍可以看出，map、filter或者reduce实际都是对序列类型数据的成员进行操作。由于这种操作在python是非常普遍的，因此在python 2.0后提供了一种叫"list的再构造"（英文名叫list comprehansions，不知道怎么翻合适）的语法形式来进行类似的操作。假设L = [1,2,3,4]，那么：map((lambda x: x**2), L)就可以写成：[x**2 for x in L]。这就是所谓的"list的再构造"。认真来看看这个：

• [x**2 for x in L]    ===> [1,4,9,16]
  

首先，这个表达式用[]括起来了，表示这个表达式返回的结果是一个list。其次，后面一部分，也就是for x in L，很明显是把L中的成员依次取出来。第三，前面一部分，也就是x**2，表示对x的操作是"平方"。然后以每次计算后的值作为目标list的成员。其实可以把这一部分看成是目标list的“通项公式”，通过对这个“通项公式”代入不同的值，可以得到不同的结果。而这个“不同的值”就是由后面的部分，即for x in L，确定的。

• [(x**2,x**3) for x in L] ===> [(1, 1), (4, 8), (9, 27), (16, 64)]

当然大名顶顶的"list再构造"还有别的功能，它可以加上条件从句（if语句），比如：

• [x**2 for x in L if x%2==0] ===>[4,16]

"list再构造"还可以嵌套for这一部分，比如：

• [x*y for x in L for y in L] ===> [1, 2, 3, 4, 2, 4, 6, 8, 3, 6, 9, 12, 4, 8, 12, 16]

相当于：

1. res = []
2. for x in L:
3.      for y in L:
4.         res.append(x*y)
5. res

当然，嵌套for的"list再构造"也可以加上条件判断。比如：

• [x*y for x in L if x%2==0 for y in L if y%2 != 0]   ===>[2, 6, 4, 12]
  

这个式子已经相当复杂，因此在以程序可读性著称的python世界中，最好不要使用这种东西。不过，也可见用“list再构造”也可以实现for或者map和filter的功能，但是list再构造的效率最高，其次map、filter这些内置函数，再次才是for。

 

类别：Python | 添加到搜藏 | 浏览(100) | 评论 (0) <script></script>

 

上一篇：python（23）: 发生器和循环器（...    下一篇：Twisted的网络通信模型