Python 研究(Dive Into Python)

lastwinner

进一步阅读

• Python Tutorial 讨论了 使用内置过滤器函数 过滤列表的另一种方式。

lastwinner

4.6. and 和 or 的特殊性质
4.6.1. 使用 and-or 技巧
在Python 中，and 和 or 执行布尔逻辑演算，如你所期待的一样，但是它们并不返回布尔值；而是，返回它们实际进行比较的值之一。

例 4.15. and 介绍
>>> 'a' and 'b'         
'b'
>>> '' and 'b'         
''
>>> 'a' and 'b' and 'c'
'c'  使用 and 时，在布尔上下文中从左到右演算表达式的值。0、''、[]、()、{}、None 在布尔上下文中为假；其它任何东西都为真。还好，几乎是所有东西。默认情况下，布尔上下文中的类实例为真，但是你可以在类中定义特定的方法使得类实例的演算值为假。你将会在第 5 章中了解到类和这些特殊方法。如果布尔上下文中的所有值都为真，那么 and 返回最后一个值。在这个例子中，and 演算 'a' 的值为真，然后是 'b' 的演算值为真，最终返回 'b'。
  如果布尔上下文中的某个值为假，则 and 返回第一个假值。在这个例子中，'' 是第一个假值。
  所有值都为真，所以 and 返回最后一个真值，'c'。

例 4.16. or 介绍
>>> 'a' or 'b'         
'a'
>>> '' or 'b'           
'b'
>>> '' or [] or {}      
{}
>>> def sidefx():
...     print "in sidefx()"
...     return 1
>>> 'a' or sidefx()     
'a'  使用 or 时，在布尔上下文中从左到右演算值，就像 and 一样。如果有一个值为真，or 立刻返回该值。本例中，'a' 是第一个真值。
  or 演算 '' 的值为假，然后演算 'b' 的值为真，于是返回 'b' 。
  如果所有的值都为假，or 返回最后一个假值。or 演算 '' 的值为假，然后演算 [] 的值为假，依次演算 {} 的值为假，最终返回 {} 。
  注意 or 在布尔上下文中会一直进行表达式演算直到找到第一个真值，然后就会忽略剩余的比较值。如果某些值具有副作用，这种特性就非常重要了。在这里，函数 sidefx 永远都不会被调用，因为 or 演算 'a' 的值为真，所以紧接着就立刻返回 'a' 了。

如果你是一名 C 语言黑客，肯定很熟悉 bool ? a : b 表达式，如果 bool 为真，表达式演算值为 a，否则为 b。基于 Python 中 and 和 or 的工作方式，你可以完成相同的事情。

lastwinner

4.6.1. 使用 and-or 技巧
例 4.17. and-or 技巧介绍
>>> a = "first"
>>> b = "second"
>>> 1 and a or b
'first'
>>> 0 and a or b
'second'
  这个语法看起来类似于 C 语言中的 bool ? a : b 表达式。整个表达式从左到右进行演算，所以先进行 and 表达式的演算。 1 and 'first' 演算值为 'first'，然后 'first' or 'second' 的演算值为 'first'。
  0 and 'first' 演算值为 False，然后 0 or 'second' 演算值为 'second'。

然而，由于这种 Python 表达式单单只是进行布尔逻辑运算，并不是语言的特定构成，这是 and-or 技巧和 C 语言中的 bool ? a : b 语法非常重要的不同。如果 a 为假，表达式就不会按你期望的那样工作了。（你能知道我被这个问题折腾过吗？不只一次？）

例 4.18. and-or 技巧无效的场合
>>> a = ""
>>> b = "second"
>>> 1 and a or b         
'second'  由于 a 是一个空字符串，在 Python 的布尔上下文中空字符串被认为是假的，1 and '' 的演算值为 ''，最后 '' or 'second' 的演算值为 'second'。噢！这个值并不是你想要的。

and-or 技巧，bool and a or b 表达式，当 a 在布尔上下文中的值为假时，不会像 C 语言表达式 bool ? a : b 那样工作。

在 and-or 技巧后面真正的技巧是，确保 a 的值决不会为假。最常用的方式是使 a 成为 [a] 、 b 成为 ，然后使用返回值列表的第一个元素，应该是 a 或 b中的某一个。

例 4.19. 安全使用 and-or 技巧
>>> a = ""
>>> b = "second"
>>> (1 and [a] or )[0]
''  由于 [a] 是一个非空列表，所以它决不会为假。即使 a 是 0 或者 '' 或者其它假值，列表 [a] 也为真，因为它有一个元素。

到现在为止，这个技巧可能看上去问题超过了它的价值。毕竟，使用 if 语句可以完成相同的事情，那为什么要经历这些麻烦事呢？哦，在很多情况下，你要在两个常量值中进行选择，由于你知道 a 的值总是为真，所以你可以使用这种较为简单的语法而且不用担心。对于使用更为复杂的安全形式，依然有很好的理由要求这样做。例如，在 Python 语言的某些情况下 if 语句是不允许使用的，比如在 lambda 函数中。

lastwinner

进一步阅读

• Python Cookbook 讨论了 其它的 and-or 技巧。

lastwinner

4.7. 使用 lambda 函数
4.7.1. 真实世界中的 lambda 函数
Python 支持一种有趣的语法，它允许你快速定义单行的最小函数。这些叫做 lambda 的函数，是从 Lisp 借用来的，可以用在任何需要函数的地方。

例 4.20. lambda 函数介绍
>>> def f(x):
...     return x*2
...     
>>> f(3)
6
>>> g = lambda x: x*2  
>>> g(3)
6
>>> (lambda x: x*2)(3)
6  这是一个 lambda 函数，完成同上面普通函数相同的事情。注意这里的简短的语法：在参数列表周围没有括号，而且忽略了 return 关键字（隐含存在，因为整个函数只有一行）。 而且，该函数没有函数名称，但是可以将它赋值给一个变量进行调用。
  你可以使用 lambda 函数甚至不需要将它赋值给一个变量。这可能不是世上最有用的东西，它只是展示了 lambda 函数只是一个内联函数。

总的来说，lambda 函数可以接收任意多个参数（包括 可选参数）并且返回单个表达式的值。lambda 函数不能包含命令，包含的表达式不能超过一个。不要试图向 lambda 函数中塞入太多的东西；如果你需要更复杂的东西，应该定义一个普通函数，然后想让它多长就多长。


lambda 函数是一种风格问题。不一定非要使用它们；任何能够使用它们的地方，都可以定义一个单独的普通函数来进行替换。我将它们用在需要封装特殊的、非重用代码上，避免另我的代码充斥着大量单行函数。

lastwinner

4.7.1. 真实世界中的 lambda 函数
apihelper.py 中的 lambda 函数：

    processFunc = collapse and (lambda s: " ".join(s.split())) or (lambda s: s)注意这里使用了 and-or 技巧的简单形式，它是没问题的，因为 lambda 函数 在布尔上下文中总是为真。（这并不意味这 lambda 函数不能返回假值。这个函数对象的布尔值为真；它的返回值可以是任何东西。）

还要注意的是使用了没有参数的 split 函数。你已经看到过它带一个或者两个参数的使用，但是不带参数它按空白进行分割。

例 4.21. split 不带参数
>>> s = "this   is\na\ttest"  
>>> print s
this   is
a        test
>>> print s.split()           
['this', 'is', 'a', 'test']
>>> print " ".join(s.split())
'this is a test'  这是一个多行字符串，通过使用转义字符的定义代替了 三重引号。\n 是一个回车，\t 是一个制表符。
  不带参数的 split 按照空格进行分割。所以三个空格、一个回车和一个制表符都是一样的。
  通过 split 分割字符串你可以将空格统一化；然后再以单个空格作为分隔符用 join 将其重新连接起来。这也就是 info 函数将多行 doc string 合并成单行所做的事情。

那么 info 函数到底用这些 lambda 函数、split 函数和 and-or 技巧做了些什么呢？

    processFunc = collapse and (lambda s: " ".join(s.split())) or (lambda s: s)processFunc 现在是一个函数，但是它到底是哪一个函数还要取决于 collapse 变量。如果 collapse 为真，processFunc(string) 将压缩空白；否则 processFunc(string) 将返回未改变的参数。

在一个不很健壮的语言中实现它，像 Visual Basic，你很有可能要创建一个函数，接受一个字符串参数和一个 collapse 参数，并使用 if 语句确定是否压缩空白，然后再返回相应的值。这种方式是低效的，因为函数可能需要处理每一种可能的情况。每次你调用它，它将不得不在给出你所想要的东西之前，判断是否要压缩空白。在 Python 中，你可以将决策逻辑拿到函数外面，而定义一个裁减过的 lambda 函数提供确切的（唯一的）你想要的。这种方式更为高效、更为优雅，而且很少引起那些令人讨厌（哦，想到那些参数就头昏）的错误。

lastwinner

lambda 函数进一步阅读

• Python Knowledge Base 讨论了使用 lambda 来间接调用函数。
• Python Tutorial 演示了如何 从一个 lambda 函数内部访问外部变量。（PEP 227 解释了在 Python 的未来版本中将如何变化。）
• The Whole Python FAQ 有关于 令人模糊的使用 lambda 单行语句的例子。

lastwinner

4.8. 全部放在一起
最后一行代码是唯一还没有解释过的，它完成全部的工作。但是现在工作已经简单了，因为所需要的每件事都已经按照需求建立好了。所有的多米诺骨牌已经就位，到了将它们推倒的时候了。

下面是 apihelper.py 的根本

    print "\n".join(["%s %s" %
                      (method.ljust(spacing),
                       processFunc(str(getattr(object, method).__doc__)))
                     for method in methodList])注意这是一条命令，被分隔成了多行，但是并没有使用续行符（\）。还记得我说过 一些表达式可以分割成多行 而不需要使用反斜线吗？列表解析就是这些表达式之一，因为整个表达式包括在方括号里。

现在，让我们从后向前分析。这个


for method in methodList告诉我们这是一个 列表解析。 如你所知 methodList 是 object 中 所有你关心的方法 的一个列表。所以你正在使用 method 遍历列表。

例 4.22. 动态得到 doc string
>>> import odbchelper
>>> object = odbchelper                  
>>> method = 'buildConnectionString'      
>>> getattr(object, method)               
<function buildConnectionString at 010D6D74>
>>> print getattr(object, method).__doc__
Build a connection string from a dictionary of parameters.

    Returns string.  在 info 函数中，object 是要得到帮助的对象，作为一个参数传入。
  在你遍历 methodList 时，method 是当前方法的名称。
  通过 getattr 函数，你可以得到 object 模块中 method 函数的引用。
  现在，很容易就可以打印出方法的 doc string 。

接下来令人困惑的是 doc string 周围 str 的使用。你可能记得，str 是一个内置函数，它可以 强制将数据转化为字符串。但是一个 doc string 应该总是一个字符串，为什么还要费事的使用 str 函数呢？答案就是：不是每个函数都有 doc string ，如果没有，这个 __doc__ 属性为 None。

例 4.23. 为什么对一个 doc string 使用 str ？
>>> >>> def foo(): print 2
>>> >>> foo()
2
>>> >>> foo.__doc__     
>>> foo.__doc__ == None
True
>>> str(foo.__doc__)   
'None'
  你可以很容易的定义一个没有 doc string 的函数，这种情况下它的 __doc__ 属性为 None。 令人迷惑的是，如果你直接演算 __doc__ 属性的值，Python IDE 什么都不会打印，如果你只是考虑它，是有意义的，但是却没有什么用。
  你可以直接通过 __doc__ 属性和 None 的比较验证 __doc__ 属性的值。
  str 函数可以接收值为 null 的参数，然后返回它的字符串表示，'None'。


在 SQL 中，你必须使用 IS NULL 代替 = NULL 进行 null 值比较。在 Python，你可以使用 == None 或者 is None 进行比较，但是 is None 更快。

现在你确保有了一个字符串，可以把这个字符串传给 processFunc，这个函数 已经定义 是一个既可以压缩空白也可以不压缩空白的函数。现在你看出来为什么使用 str 将 None 转化为一个字符串很重要了。processFunc 假设接收到一个字符串参数然后调用 split 方法，如果你传入 None ，将导致程序崩溃，因为 None 没有 split 方法。

再往回走一步，你再一次使用了字符串格式化来连接 processFunc 的返回值 和 method 的 ljust 方法的返回值。ljust 是一个你之前没有见过的新字符串方法。

例 4.24. ljust 方法介绍
>>> s = 'buildConnectionString'
>>> s.ljust(30)
'buildConnectionString         '
>>> s.ljust(20)
'buildConnectionString'  ljust 用空格填充字符串以符合指定的长度。info 函数使用它生成了两列输出并将所有在第二列的 doc string 纵向对齐。
  如果指定的长度小于字符串的长度，ljust 将简单的返回未变化的字符串。它决不会截断字符串。

几乎已经完成了。有了 ljust 方法填充过的方法名称和来自调用 processFunc 方法得到的 doc string（可能压缩过），你就可以将两者连接起来并得到单个字符串。因为对 methodList 进行了映射，最终你将获得一个字符串列表。利用 "\n" 的 join 函数，将这个列表连接为单个字符串，列表中每个元素独占一行，接着打印出结果。

例 4.25. 打印列表
>>> li = ['a', 'b', 'c']
>>> print "\n".join(li)
a
b
c  在你处理列表时，这确实是一个有用的调试技巧。还有一点在 Python 中，你总是在操纵列表。

上述就是最后一个令人困惑的地方了。但是现在你应该已经理解这段代码了。

    print "\n".join(["%s %s" %
                      (method.ljust(spacing),
                       processFunc(str(getattr(object, method).__doc__)))
                     for method in methodList])

lastwinner

4.9. 小结
apihelper.py 程序和它的输出现在应该非常清晰了。


def info(object, spacing=10, collapse=1):
    """Print methods and doc strings.
   
    Takes module, class, list, dictionary, or string."""
    methodList = [method for method in dir(object) if callable(getattr(object, method))]
    processFunc = collapse and (lambda s: " ".join(s.split())) or (lambda s: s)
    print "\n".join(["%s %s" %
                      (method.ljust(spacing),
                       processFunc(str(getattr(object, method).__doc__)))
                     for method in methodList])

if __name__ == "__main__":
    print info.__doc__apihelper.py 的输出：

>>> from apihelper import info
>>> li = []
>>> info(li)
append     L.append(object) -- append object to end
count      L.count(value) -> integer -- return number of occurrences of value
extend     L.extend(list) -- extend list by appending list elements
index      L.index(value) -> integer -- return index of first occurrence of value
insert     L.insert(index, object) -- insert object before index
pop        L.pop([index]) -> item -- remove and return item at index (default last)
remove     L.remove(value) -- remove first occurrence of value
reverse    L.reverse() -- reverse *IN PLACE*
sort       L.sort([cmpfunc]) -- sort *IN PLACE*; if given, cmpfunc(x, y) -> -1, 0, 1在研究下一章前，确保你可以无困难的完成下面这些事情：

用可选和命名参数定义和调用函数
用 str 强制转换任意值为字符串形式
用 getattr 动态得到函数和其它属性的引用
扩展列表解析语法实现 列表过滤
识别 and-or 技巧 并安全的使用它
定义 lambda 函数
将函数赋值给变量 然后通过引用变量调用函数。我强调的已经够多了：这种思考方式对于提高对 Python 的理解力至关重要。在本书中你会随处可见这种技术的更复杂的应用。

lastwinner

第 5 章 对象和面向对象
5.1. 概览
5.2. 使用 from module import 导入模块
5.3. 类的定义
5.3.1. 初始化并开始类编码
5.3.2. 了解何时去使用 self 和 __init__
5.4. 类的实例化
5.4.1. 垃圾回收
5.5. 探索 UserDict: 一个封装类
5.6. 专用类方法
5.6.1. 获得和设置数据项
5.7. 高级专用类方法
5.8. 类属性介绍
5.9. 私有函数
5.10. 小结
这一章，和此后的许多章，均讨论了面向对象的 Python 程序设计。