Dive Into Python

例 1.1. 两个 Python 版本

[localhost:~] you% python
Python 2.2 (#1, 07/14/02, 23:25:09)
[GCC Apple cpp-precomp 6.14] on darwin
Type "help", "copyright", "credits", or "license" for more information.
>>> [press Ctrl+D to get back to the command prompt]
[localhost:~] you% /usr/local/bin/python
Python 2.3 (#2, Jul 30 2003, 11:45:28)
[GCC 3.1 20020420 (prerelease)] on darwin
Type "help", "copyright", "credits", or "license" for more information.
>>> [press Ctrl+D to get back to the command prompt]
[localhost:~] you% 

例 1.2. 在 RedHat Linux 9 上安装

localhost:~$ su -
Password: [enter your root password]
[root@localhost root]# wget http://python.org/ftp/python/2.3/rpms/redhat-9/python2.3-2.3-5pydotorg.i386.rpm
Resolving python.org... done.
Connecting to python.org[194.109.137.226]:80... connected.
HTTP request sent, awaiting response... 200 OK
Length: 7,495,111 [application/octet-stream]
...
[root@localhost root]# rpm -Uvh python2.3-2.3-5pydotorg.i386.rpm
Preparing...                ########################################### [100%]
   1:python2.3              ########################################### [100%]
[root@localhost root]# python          
Python 2.2.2 (#1, Feb 24 2003, 19:13:11)
[GCC 3.2.2 20030222 (Red Hat Linux 3.2.2-4)] on linux2
Type "help", "copyright", "credits", or "license" for more information.
>>> [press Ctrl+D to exit]
[root@localhost root]# python2.3       
Python 2.3 (#1, Sep 12 2003, 10:53:56)
[GCC 3.2.2 20030222 (Red Hat Linux 3.2.2-5)] on linux2
Type "help", "copyright", "credits", or "license" for more information.
>>> [press Ctrl+D to exit]
[root@localhost root]# which python2.3 
/usr/bin/python2.3

	仅仅键入 python 运行的是老版本的 Python ――它是缺省安装的版本。它不是我们想要的。
	截止到笔者写作时，新的版本是 python2.3。您可能会需要修改示例脚本的第一行的路径指向新版本。
	这是我们刚安装的 Python 新版本的全路径。在 #! 行中 (每个脚本的第一行) 使用它来确保脚本运行在最新版的 Python 下，并且确保敲入的是 python2.3 进入交互shell。

例 1.3. 在 Debian GNU/Linux 上安装

localhost:~$ su -
Password: [enter your root password]
localhost:~# apt-get install python
Reading Package Lists... Done
Building Dependency Tree... Done
The following extra packages will be installed:
  python2.3
Suggested packages:
  python-tk python2.3-doc
The following NEW packages will be installed:
  python python2.3
0 upgraded, 2 newly installed, 0 to remove and 3 not upgraded.
Need to get 0B/2880kB of archives.
After unpacking 9351kB of additional disk space will be used.
Do you want to continue? [Y/n] Y
Selecting previously deselected package python2.3.
(Reading database ... 22848 files and directories currently installed.)
Unpacking python2.3 (from .../python2.3_2.3.1-1_i386.deb) ...
Selecting previously deselected package python.
Unpacking python (from .../python_2.3.1-1_all.deb) ...
Setting up python (2.3.1-1) ...
Setting up python2.3 (2.3.1-1) ...
Compiling python modules in /usr/lib/python2.3 ...
Compiling optimized python modules in /usr/lib/python2.3 ...
localhost:~# exit
logout
localhost:~$ python
Python 2.3.1 (#2, Sep 24 2003, 11:39:14)
[GCC 3.3.2 20030908 (Debian prerelease)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> [press Ctrl+D to exit]

例 1.4. 从源代码安装

localhost:~$ su -
Password: [enter your root password]
localhost:~# wget http://www.python.org/ftp/python/2.3/Python-2.3.tgz
Resolving www.python.org... done.
Connecting to www.python.org[194.109.137.226]:80... connected.
HTTP request sent, awaiting response... 200 OK
Length: 8,436,880 [application/x-tar]
...
localhost:~# tar xfz Python-2.3.tgz
localhost:~# cd Python-2.3
localhost:~/Python-2.3# ./configure
checking MACHDEP... linux2
checking EXTRAPLATDIR...
checking for --without-gcc... no
...
localhost:~/Python-2.3# make
gcc -pthread -c -fno-strict-aliasing -DNDEBUG -g -O3 -Wall -Wstrict-prototypes
-I. -I./Include  -DPy_BUILD_CORE -o Modules/python.o Modules/python.c
gcc -pthread -c -fno-strict-aliasing -DNDEBUG -g -O3 -Wall -Wstrict-prototypes
-I. -I./Include  -DPy_BUILD_CORE -o Parser/acceler.o Parser/acceler.c
gcc -pthread -c -fno-strict-aliasing -DNDEBUG -g -O3 -Wall -Wstrict-prototypes
-I. -I./Include  -DPy_BUILD_CORE -o Parser/grammar1.o Parser/grammar1.c
...
localhost:~/Python-2.3# make install
/usr/bin/install -c python /usr/local/bin/python2.3
...
localhost:~/Python-2.3# exit
logout
localhost:~$ which python
/usr/local/bin/python
localhost:~$ python
Python 2.3.1 (#2, Sep 24 2003, 11:39:14)
[GCC 3.3.2 20030908 (Debian prerelease)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> [press Ctrl+D to get back to the command prompt]
localhost:~$ 

例 1.5. 初次使用交互 Shell

>>> 1 + 1               
2
>>> print 'hello world' 
hello world
>>> x = 1               
>>> y = 2
>>> x + y
3

	Python 的交互 shell 可以计算任意的 Python 表达式，包括任何基本的数学表达式。
	交互 shell 可以执行任意的 Python 语句，包括 print 语句。
	也可以给变量赋值，并且变量值在 shell 打开时一直有效 (一旦关毕交互 Sheel，变量值将丢失)。

例 2.1. odbchelper.py

如果您还没有下载本书附带的样例程序, 可以 下载本程序和其他样例程序。

def buildConnectionString(params):
    """Build a connection string from a dictionary of parameters.

    Returns string."""
    return ";".join(["%s=%s" % (k, v) for k, v in params.items()])

if __name__ == "__main__":
    myParams = {"server":"mpilgrim", \
                "database":"master", \
                "uid":"sa", \
                "pwd":"secret" \
                }
    print buildConnectionString(myParams)

例 2.2. 定义 buildConnectionString 函数的 doc string

def buildConnectionString(params):
    """Build a connection string from a dictionary of parameters.

    Returns string."""

三重引号表示一个多行字符串。在开始与结束引号间的所有东西都被视为单个字符串的一部分，包括硬回车和其它的引号字符。您可以在任何地方使用它们，但是您可能会发现，它们经常被用于定义 doc string。

例 2.3. 访问 buildConnectionString 函数的 doc string

>>> import odbchelper                              
>>> params = {"server":"mpilgrim", "database":"master", "uid":"sa", "pwd":"secret"}
>>> print odbchelper.buildConnectionString(params) 
server=mpilgrim;uid=sa;database=master;pwd=secret
>>> print odbchelper.buildConnectionString.__doc__ 
Build a connection string from a dictionary

Returns string.

	第一行将 odbchelper 程序作为模块导入。模块是指一个可以交互使用，或者从另一 Python 程序访问的代码段。(您在 第 4 章 将会看到多模块 Python 程序的许多例子。) 只要导入了一个模块，就可以引用它的任何公共的函数、类或属性。模块可以通过这种方法来使用其它模块的功能，您也可以在 IDE 中这样做。这是一个很重要的概念，在后面我们将谈得更多。
	当使用在被导入模块中定义的函数时，必须包含模块的名字。所以不能只使用 buildConnectionString，而应该使用 odbchelper.buildConnectionString。如果您用过 Java 的类，对此应该不感到陌生。
	访问函数的 __doc__ 属性不像您想象的那样是通过函数调用。

例 2.5. 缩进 buildConnectionString 函数

def buildConnectionString(params):
    """Build a connection string from a dictionary of parameters.

    Returns string."""
    return ";".join(["%s=%s" % (k, v) for k, v in params.items()])

例 2.6. if 语句

def fib(n):                   
    print 'n =', n            
    if n > 1:                 
        return n * fib(n - 1)
    else:                     
        print 'end of the line'
        return 1

	这是一个名为 fib 的函数，有一个参数 n。在函数内的所有代码都是缩进的。
	在 Python 中向屏幕输出内容非常容易，只要使用 print 即可。print 语句可以接受任何数据类型，包括字符串、整数和其它类型，如字典和列表 (我们将在下一章学习)。甚至可以混在一起输出，只需用逗号隔开。所有值都输出到同一行，用空格隔开 (逗号并不打印出来)。所以当用 5 来调用 fib 时，将输出“n = 5”。
	if 语句是一种的代码块。如果 if 表达式计算为 true，紧跟着的缩进块会被执行，否则进入 else 块执行。
	当然 if 和 else 块可以包含许多行，只要它们都同样缩进。这个 else 块中有两行代码。对于多行代码块没有其它特殊的语法，只要缩进就行了。

例 3.15. 定义 tuple

>>> t = ("a", "b", "mpilgrim", "z", "example") 
>>> t
('a', 'b', 'mpilgrim', 'z', 'example')
>>> t[0]                                       
'a'
>>> t[-1]                                      
'example'
>>> t[1:3]                                     
('b', 'mpilgrim')

	定义 tuple 与定义 list 的方式相同，但整个元素集是用小括号包围的，而不是方括号。
	Tuple 的元素与 list 一样按定义的次序进行排序。Tuples 的索引与 list 一样从 0 开始，所以一个非空 tuple 的第一个元素总是 t[0]。
	负数索引与 list 一样从 tuple 的尾部开始计数。
	与 list 一样分片 (slice) 也可以使用。注意当分割一个 list 时，会得到一个新的 list ；当分割一个 tuple 时，会得到一个新的 tuple。

例 3.16. Tuple 没有方法

>>> t
('a', 'b', 'mpilgrim', 'z', 'example')
>>> t.append("new")    
Traceback (innermost last):
  File "<interactive input>", line 1, in ?
AttributeError: 'tuple' object has no attribute 'append'
>>> t.remove("z")      
Traceback (innermost last):
  File "<interactive input>", line 1, in ?
AttributeError: 'tuple' object has no attribute 'remove'
>>> t.index("example") 
Traceback (innermost last):
  File "<interactive input>", line 1, in ?
AttributeError: 'tuple' object has no attribute 'index'
>>> "z" in t           
True

	您不能向 tuple 增加元素。Tuple 没有 append 或 extend 方法。
	您不能从 tuple 删除元素。Tuple 没有 remove 或 pop 方法。
	您不能在 tuple 中查找元素。Tuple 没有 index 方法。
	然而，您可以使用 in 来查看一个元素是否存在于 tuple 中。

例 3.17. 定义 myParams 变量

if __name__ == "__main__":
    myParams = {"server":"mpilgrim", \
                "database":"master", \
                "uid":"sa", \
                "pwd":"secret" \
                }

例 3.21. 字符串的格式化

>>> k = "uid"
>>> v = "sa"
>>> "%s=%s" % (k, v) 
'uid=sa'

整个表达式的值为一个字符串。第一个 %s 被变量 k 的值替换；第二个 %s 被 v 的值替换。字符串中的所有其它字符 (在这个例子中，是等号) 按原样打印输出。

例 3.22. 字符串格式化与字符串连接的比较

>>> uid = "sa"
>>> pwd = "secret"
>>> print pwd + " is not a good password for " + uid      
secret is not a good password for sa
>>> print "%s is not a good password for %s" % (pwd, uid) 
secret is not a good password for sa
>>> userCount = 6
>>> print "Users connected: %d" % (userCount, )            
Users connected: 6
>>> print "Users connected: " + userCount                 
Traceback (innermost last):
  File "<interactive input>", line 1, in ?
TypeError: cannot concatenate 'str' and 'int' objects

	+ 是字符串连接操作符。
	在这个简单例子中，字符串格式化实现与连接一样的结果。
	(userCount, ) 是一个只包含一个元素的 tuple。是的，语法有一点奇怪，但是使用它的理由就是：显示地指出它是一个 tuple，而不是其他。实际上，当定义一个 list、tuple 或 dictionary 时，您可以总是在最后一个元素后面跟上一个逗号，但是当定义一个只包含一个元素的 tuple 时逗号是必须的。如果省略逗号，Python 不会知道 (userCount) 究竟是一个只包含一个元素的 tuple 还是变量 userCount 的值。
	字符串格式化通过将 %s 替换成 %d 即可处理整数。
	试图将一个字符串同一个非字符串连接会引发一个异常。与字符串格式化不同，字符串连接只能在被连接的每一个都是字符串时起作用。

例 3.23. 数值的格式化

>>> print "Today's stock price: %f" % 50.4625   
50.462500
>>> print "Today's stock price: %.2f" % 50.4625 
50.46
>>> print "Change since yesterday: %+.2f" % 1.5 
+1.50

	%f 格式符选项对应一个十进制浮点数，不指定精度时打印 6 位小数。
	使用包含“.2”精度修正符的 %f 格式符选项将只打印 2 位小数。
	您甚至可以混合使用各种修正符。添加 + 修正符用于在数值之前显示一个正号或负号。注意“.2”精度修正符仍旧在它原来的位置，用于只打印 2 位小数。

例 3.24. List 解析介绍

>>> li = [1, 9, 8, 4]
>>> [elem*2 for elem in li]      
[2, 18, 16, 8]
>>> li                           
[1, 9, 8, 4]
>>> li = [elem*2 for elem in li] 
>>> li
[2, 18, 16, 8]

	为了便于理解它，让我们从右向左看。li 是一个将要映射的 list。Python 循环遍历 li 中的每个元素。对每个元素均执行如下操作：首先临时将其值赋给变量 elem，然后 Python 应用函数 elem*2 进行计算，最后将计算结果追加到要返回的 list 中。
	需要注意是，对 list 的解析并不改变原始的 list。
	将一个 list 的解析结果赋值给对其映射的变量是安全的。不用担心存在竞争情况或任何古怪事情的发生。Python 会在内存中创建新的 list，当对 list 的解析完成时，Python 将结果赋给变量。

例 3.25. keys, values 和 items 函数

>>> params = {"server":"mpilgrim", "database":"master", "uid":"sa", "pwd":"secret"}
>>> params.keys()   
['server', 'uid', 'database', 'pwd']
>>> params.values() 
['mpilgrim', 'sa', 'master', 'secret']
>>> params.items()  
[('server', 'mpilgrim'), ('uid', 'sa'), ('database', 'master'), ('pwd', 'secret')]

	Dictionary 的 keys 方法返回一个包含所有键的 list。这个 list 没按 dictionary 定义的顺序输出 (记住，元素在 dictionary 中是无序的)，但它是一个 list。
	values 方法返回一个包含所有值的 list。它同 keys 方法返回的 list 输出顺序相同，所以对于所有的 n，params.values()[n] == params[params.keys()[n]] 。
	items 方法返回一个由形如 (key，value) 组成的 tuple 的 list。这个 list 包括 dictionary 中所有的数据。

例 3.26. buildConnectionString 中的 list 解析

>>> params = {"server":"mpilgrim", "database":"master", "uid":"sa", "pwd":"secret"}
>>> params.items()
[('server', 'mpilgrim'), ('uid', 'sa'), ('database', 'master'), ('pwd', 'secret')]
>>> [k for k, v in params.items()]                
['server', 'uid', 'database', 'pwd']
>>> [v for k, v in params.items()]                
['mpilgrim', 'sa', 'master', 'secret']
>>> ["%s=%s" % (k, v) for k, v in params.items()] 
['server=mpilgrim', 'uid=sa', 'database=master', 'pwd=secret']

	请注意我们正在使用两个变量对 list params.items() 进行遍历。这是多变量赋值的另一种用法。params.items() 的第一个元素是 ('server', 'mpilgrim')，所以在 list 解析的第一次遍历中，k 将为 'server'，v 将为 'mpilgrim'。在本例中，我们忽略了返回 list 中 v 的值，而只包含了 k 的值，所以这个 list 解析最后等于 params.keys()。
	这里我们做着相同的事情，但是忽略了 k 的值，所以这个 list 解析最后等于 params.values()。
	用一些简单的 字符串格式化将前面两个例子合并起来 ，我们就得到一个包括了 dictionary 中每个元素的 key-value 对的 list。这个看上去有点像程序的输出结果，剩下的就只是将这个 list 中的元素接起来形成一个字符串了。

例 3.27. odbchelper.py 的输出结果

>>> params = {"server":"mpilgrim", "database":"master", "uid":"sa", "pwd":"secret"}
>>> ["%s=%s" % (k, v) for k, v in params.items()]
['server=mpilgrim', 'uid=sa', 'database=master', 'pwd=secret']
>>> ";".join(["%s=%s" % (k, v) for k, v in params.items()])
'server=mpilgrim;uid=sa;database=master;pwd=secret'

例 3.28. 分割字符串

>>> li = ['server=mpilgrim', 'uid=sa', 'database=master', 'pwd=secret']
>>> s = ";".join(li)
>>> s
'server=mpilgrim;uid=sa;database=master;pwd=secret'
>>> s.split(";")    
['server=mpilgrim', 'uid=sa', 'database=master', 'pwd=secret']
>>> s.split(";", 1) 
['server=mpilgrim', 'uid=sa;database=master;pwd=secret']

	split 与 join 正好相反，它将一个字符串分割成多元素 list。注意，分隔符 (“;”) 被完全去掉了，它没有在返回的 list 中的任意元素中出现。
	split 接受一个可选的第二个参数，它是要分割的次数。(“哦，可选参数……”，您将会在下一章中学会如何在您自己的函数中使用它。)

例 4.1. 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__

	该模块有一个声明为 info 的函数。根据它的函数声明可知，它有三个参数： object、spacing 和 collapse。实际上后面两个参数都是可选参数，关于这点你很快就会看到。
	info 函数有一个多行的 doc string，简要地描述了函数的功能。注意这里并没有提到返回值；单独使用这个函数只是为了这个函数产生的效果，并不是为了它的返回值。
	函数内的代码是缩进形式的。
	if __name__ 技巧允许这个程序在自己独立运行时做些有用的事情，同时又不妨碍作为其它程序的模块使用。在这个例子中，程序只是简单地打印出 info 函数的 doc string。
	if 语句使用 == 进行比较，而且不需要括号。

例 4.2. 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

例 4.3. apihelper.py 的高级用法

>>> import odbchelper
>>> info(odbchelper)
buildConnectionString Build a connection string from a dictionary Returns string.
>>> info(odbchelper, 30)
buildConnectionString          Build a connection string from a dictionary Returns string.
>>> info(odbchelper, 30, 0)
buildConnectionString          Build a connection string from a dictionary
    
    Returns string.

例 4.4. info 的有效调用

info(odbchelper)                    
info(odbchelper, 12)                
info(odbchelper, collapse=0)        
info(spacing=15, object=odbchelper) 

	只使用一个参数，spacing 使用缺省值 10 ，collapse 使用缺省值 1。
	使用两个参数，collapse 使用缺省值 1。
	这里你显式命名了 collapse 并指定了它的值。spacing 将依然使用它的缺省值 10。
	甚至必备参数 (例如 object，没有指定缺省值) 也可以采用命名参数的方式，而且命名参数可以以任意顺序出现。

例 4.10. getattr 介绍

>>> li = ["Larry", "Curly"]
>>> li.pop                       
<built-in method pop of list object at 010DF884>
>>> getattr(li, "pop")           
<built-in method pop of list object at 010DF884>
>>> getattr(li, "append")("Moe") 
>>> li
["Larry", "Curly", "Moe"]
>>> getattr({}, "clear")         
<built-in method clear of dictionary object at 00F113D4>
>>> getattr((), "pop")           
Traceback (innermost last):
  File "<interactive input>", line 1, in ?
AttributeError: 'tuple' object has no attribute 'pop'

	该语句获取列表的 pop 方法的引用。注意该语句并不是调用 pop 方法；调用 pop 方法的应该是 li.pop()。这里指的是方法对象本身。
	该语句也是返回 pop 方法的引用，但是此时，方法名称是作为一个字符串参数传递给 getattr 函数的。getattr 是一个有用到令人无法致信的内置函数，可以返回任何对象的任何属性。在这个例子中，对象是一个 list，属性是 pop 方法。
	如果不确信它是多么的有用，试试这个：getattr 的返回值是 方法，然后你就可以调用它，就像直接使用 li.append("Moe") 一样。但是实际上你没有直接调用函数；只是以字符串形式指定了函数名称。
	getattr 也可以作用于字典。
	理论上，getattr 可以作用于元组，但是由于元组没有方法，所以不管你指定什么属性名称 getattr 都会引发一个异常。

例 4.14. 列表过滤介绍

>>> li = ["a", "mpilgrim", "foo", "b", "c", "b", "d", "d"]
>>> [elem for elem in li if len(elem) > 1]       
['mpilgrim', 'foo']
>>> [elem for elem in li if elem != "b"]         
['a', 'mpilgrim', 'foo', 'c', 'd', 'd']
>>> [elem for elem in li if li.count(elem) == 1] 
['a', 'mpilgrim', 'foo', 'c']

	这里的映射表达式很简单 (只是返回每个元素的值)，所以请把注意力集中到过滤器表达式上。由于 Python 会遍历整个列表，它将对每个元素执行过滤器表达式。如果过滤器表达式演算值为真，该元素就会被映射，同时映射表达式的结果将包含在返回的列表中。这里，你过滤掉了所有单字符的字符串，留下了一个由长字符串构成的列表。
	这里你过滤掉了一个特定值 b。注意这个过滤器会过滤掉所有的 b，因为每次取出 b，过滤表达式都将为假。
	count 是一个列表方法，返回某个值在列表中出现的次数。你可以认为这个过滤器将从列表中剔除重复元素，返回一个只包含了在原始列表中有着唯一值拷贝的列表。但并非如此，因为在原始列表中出现两次的值 (在本例中，b 和 d) 被完全剔除了。从一个列表中排除重复值有多种方法，但过滤并不是其中的一种。

例 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' 了。

例 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 函数只是一个内联函数。

例 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 。

例 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'。

例 4.24. ljust 方法介绍

>>> s = 'buildConnectionString'
>>> s.ljust(30) 
'buildConnectionString         '
>>> s.ljust(20) 
'buildConnectionString'

	ljust 用空格填充字符串以符合指定的长度。info 函数使用它生成了两列输出并将所有在第二列的 doc string 纵向对齐。
	如果指定的长度小于字符串的长度，ljust 将简单地返回未变化的字符串。它决不会截断字符串。

例 4.25. 打印列表

>>> li = ['a', 'b', 'c']
>>> print "\n".join(li) 
a
b
c

在你处理列表时，这确实是一个有用的调试技巧。在 Python 中，你会十分频繁地操作列表。

例 5.1. fileinfo.py

如果您还没有下载本书附带的样例程序, 可以 下载本程序和其他样例程序。

"""Framework for getting filetype-specific metadata.

Instantiate appropriate class with filename.  Returned object acts like a
dictionary, with key-value pairs for each piece of metadata.
    import fileinfo
    info = fileinfo.MP3FileInfo("/music/ap/mahadeva.mp3")
    print "\\n".join(["%s=%s" % (k, v) for k, v in info.items()])

Or use listDirectory function to get info on all files in a directory.
    for info in fileinfo.listDirectory("/music/ap/", [".mp3"]):
        ...

Framework can be extended by adding classes for particular file types, e.g.
HTMLFileInfo, MPGFileInfo, DOCFileInfo.  Each class is completely responsible for
parsing its files appropriately; see MP3FileInfo for example.
"""
import os
import sys
from UserDict import UserDict

def stripnulls(data):
    "strip whitespace and nulls"
    return data.replace("\00", "").strip()

class FileInfo(UserDict):
    "store file metadata"
    def __init__(self, filename=None):
        UserDict.__init__(self)
        self["name"] = filename

class MP3FileInfo(FileInfo):
    "store ID3v1.0 MP3 tags"
    tagDataMap = {"title"   : (  3,  33, stripnulls),
                  "artist"  : ( 33,  63, stripnulls),
                  "album"   : ( 63,  93, stripnulls),
                  "year"    : ( 93,  97, stripnulls),
                  "comment" : ( 97, 126, stripnulls),
                  "genre"   : (127, 128, ord)}

    def __parse(self, filename):
        "parse ID3v1.0 tags from MP3 file"
        self.clear()
        try:                               
            fsock = open(filename, "rb", 0)
            try:                           
                fsock.seek(-128, 2)        
                tagdata = fsock.read(128)  
            finally:                       
                fsock.close()              
            if tagdata[:3] == "TAG":
                for tag, (start, end, parseFunc) in self.tagDataMap.items():
                    self[tag] = parseFunc(tagdata[start:end])               
        except IOError:                    
            pass                           

    def __setitem__(self, key, item):
        if key == "name" and item:
            self.__parse(item)
        FileInfo.__setitem__(self, key, item)

def listDirectory(directory, fileExtList):                                        
    "get list of file info objects for files of particular extensions"
    fileList = [os.path.normcase(f)
                for f in os.listdir(directory)]           
    fileList = [os.path.join(directory, f) 
               for f in fileList
                if os.path.splitext(f)[1] in fileExtList] 
    def getFileInfoClass(filename, module=sys.modules[FileInfo.__module__]):      
        "get file info class from filename extension"                             
        subclass = "%sFileInfo" % os.path.splitext(filename)[1].upper()[1:]       
        return hasattr(module, subclass) and getattr(module, subclass) or FileInfo
    return [getFileInfoClass(f)(f) for f in fileList]                             

if __name__ == "__main__":
    for info in listDirectory("/music/_singles/", [".mp3"]): 
        print "\n".join(["%s=%s" % (k, v) for k, v in info.items()])
        print

这个程序的输入要取决于你硬盘上的文件。为了得到有意义的输出，你应该修改目录路径指向你自已机器上的一个 MP3 文件目录。

例 5.2. import module vs. from module import

>>> import types
>>> types.FunctionType             
<type 'function'>
>>> FunctionType                   
Traceback (innermost last):
  File "<interactive input>", line 1, in ?
NameError: There is no variable named 'FunctionType'
>>> from types import FunctionType 
>>> FunctionType                   
<type 'function'>

	types 模块不包含方法，只是表示每种 Python 对象类型的属性。注意这个属性必需用模块名 types 进行限定。
	FunctionType 本身没有被定义在当前名字空间中；它只存在于 types 的上下文环境中。
	这个语法从 types 模块中直接将 FunctionType 属性导入到局部名字空间中。
	现在 FunctionType 可以直接使用，与 types 无关了。

例 5.3. 最简单的 Python 类

class Loaf: 
    pass     

	这个类的名字是 Loaf，它没有从其它类继承。类名通常是第一个字母大写，如：EachWordLikeThis，但这只是一个习惯，不是一个必要条件。
	这个类没有定义任何方法或属性，但是从语法上，需要在定义中有些东西，所以你使用 pass。这是一个 Python 保留字，仅仅表示 “向前走，不要往这看”。它是一条什么都不做的语句，当你删空函数或类时，它是一个很好的占位符。
	你可能猜到了，在类中的所有东西都要缩近，就像位于函数、if 语句，for 循环，诸如此类的代码。第一条不缩近的东西不属于这个类。

例 5.4. 定义 FileInfo 类

from UserDict import UserDict

class FileInfo(UserDict): 

在 Python 中，类的基类只是简单地列在类名后面的小括号里。所以 FileInfo 类是从 UserDict 类 (它是从 UserDict 模块导进来的) 继承来的。UserDict 是一个像字典一样工作的类，它允许你完全子类化字典数据类型，同时增加你自已的行为。{也存在相似的类 UserList 和 UserString ，它们允许你子类化列表和字符串。)[2] 在这个类的背后有一些“巫术”，我们将在本章的后面，随着更进一步地研究 UserDict 类，揭开这些秘密。

例 5.7. 创建 FileInfo 实例

>>> import fileinfo
>>> f = fileinfo.FileInfo("/music/_singles/kairo.mp3") 
>>> f.__class__                                        
<class fileinfo.FileInfo at 010EC204>
>>> f.__doc__                                          
'store file metadata'
>>> f                                                  
{'name': '/music/_singles/kairo.mp3'}

	你正在创建 FileInfo 类 (定义在 fileinfo 模块中) 的实例，并且将新创建的实例赋值给变量 f。你传入了一个参数，/music/_singles/kairo.mp3，它将最后作为在 FileInfo 中 __init__ 方法中的 filename 参数。
	每一个类的实例有一个内置属性，__class__，它是对象的类。(注意这个表示包括了在我机器上的实例的物理地址，你的表示不会一样。)Java 程序员可能对 Class 类熟悉，这个类包含了像 getName 和 getSuperclass 之类用来得到一个对象元数据信息的方法。在 Python 中，这类元数据可以直接通过对象本身的属性，像 __class__、__name__ 和 __bases__ 来得到。
	你可以像对函数或模块一样来访问实例的 doc string。一个类的所有实例共享相同的 doc string。
	还记得什么时候 __init__ 方法将它的 filename 参数赋给 self["name"] 吗？哦，答案在这。在创建类实例时你传入的参数被正确发送到 __init__ 方法中 (当我们创建类实例时，我们所传递的参数被正确地发送给 __init__ 方法 (随同一起传递的还有对象的引用，self，它是由 Python 自动添加的)。

例 5.9. 定义 UserDict 类

class UserDict:                                
    def __init__(self, dict=None):             
        self.data = {}                         
        if dict is not None: self.update(dict)  

	注意 UserDict 是一个基类，不是从任何其他类继承而来。
	这就是我们在 FileInfo 类中进行了覆盖的 __init__ 方法。注意这个父类的参数列表与子类不同。很好，每个子类可以拥有自已的参数集，只要使用正确的参数调用父类就可以了。这里父类有一个定义初始值的方法 (通过在 dict 参数中传入一个字典)，这一方法我们的 FileInfo 没有用上。
	Python 支持数据属性 (在 Java 和 Powerbuilder 中叫做 “实例变量”，在 C++ 中叫 “数据成员”)，它是由某个特定的类实例所拥有的数据。在本例中，每个 UserDict 实例将拥有一个 data 数据属性。要从类外的代码引用这个属性，需要用实例的名字限定它，instance.data，限定的方法与你用模块的名字来限定函数一样。要在类的内部引用一个数据属性，我们使用 self 作为限定符。习惯上，所有的数据属性都在 __init__ 方法中初始化为有意义的值。然而，这并不是必须的，因为数据属性，像局部变量一样，当你首次赋给它值的时候突然产生。
	update 方法是一个字典复制器：它把一个字典中的键和值全部拷贝到另一个字典。这个操作并不 事先清空目标字典，如果一些键在目标字典中已经存在，则它们将被覆盖，那些键名在目标字典中不存在的则不改变。应该把 update 看作是合并函数，而不是复制函数。
	这个语法你可能以前没看过 (我还没有在这本书中的例子中用过它)。这是一条 if 语句，但是没有在下一行有一个缩近块，而只是在冒号后面，在同一行上有单条语句。这完全是合法的，它只是当你在一个块中仅有一条语句时的一个简写。(它就像在 C++ 中没有用大括号包括的单行语句。) 你可以用这种语法，或者可以在后面的行写下缩近代码，但是不能对同一个块同时用两种方式。

例 5.10. UserDict 常规方法

    def clear(self): self.data.clear()          
    def copy(self):                             
        if self.__class__ is UserDict:          
            return UserDict(self.data)         
        import copy                             
        return copy.copy(self)                 
    def keys(self): return self.data.keys()     
    def items(self): return self.data.items()  
    def values(self): return self.data.values()

	clear 是一个普通的类方法，可以在任何时候被任何人公开调用。注意，clear 像所有的类方法一样 (常规的或专用的)，使用 self 作为它的第一个参数。(记住，当你调用方法时，不用包括 self；这件事是 Python 替你做的。) 还应注意这个封装类的基本技术：将一个真正的字典 (data) 作为数据属性保存起来，定义所有真正字典所拥有的方法，并且将每个类方法重定向到真正字典上的相应方法。(你可能已经忘了，字典的 clear 方法删除它的所有关键字和关键字相应的值。)
	真正字典的 copy 方法会返回一个新的字典，它是原始字典的原样的复制 (所有的键-值对都相同)。但是 UserDict 不能简单地重定向到 self.data.copy，因为那个方法返回一个真正的字典，而我们想要的是返回同一个类的一个新的实例，就像是 self。
	我们使用 __class__ 属性来查看 self 是否是一个 UserDict，如果是，太好了，因为我们知道如何拷贝一个 UserDict：只要创建一个新的 UserDict ，并传给它真正的字典，这个字典已经存放在 self.data 中了。然后你立即返回这个新的 UserDict，你甚至于不需要在下面一行中使用 import copy。
	如果 self.__class__ 不是 UserDict，那么 self 一定是 UserDict 的某个子类 (如可能为 FileInfo)，生活总是存在意外。UserDict 不知道如何生成它的子类的一个原样的拷贝，例如，有可能在子类中定义了其它的数据属性，所以我们只能完全复制它们，确定拷贝了它们的全部内容。幸运的是，Python 带了一个模块可以正确地完成这件事，它叫做 copy。在这里我不想深入细节 (然而它是一个绝对酷的模块，你是否已经想到要自已研究它了呢？)。说 copy 能够拷贝任何 Python 对象就够了，这就是我们在这里用它的原因。
	其余的方法是直截了当的重定向到 self.data 的内置函数上。

例 5.11. 直接继承自内建数据类型 dict

class FileInfo(dict):                  
    "store file metadata"
    def __init__(self, filename=None): 
        self["name"] = filename

	第一个区别是你不需要导入 UserDict 模块，因为 dict 是已经可以使用的内建数据类型。第二个区别是你不是继承自 UserDict.UserDict ，而是直接继承自 dict。
	第三个区别有些晦涩，但却很重要。UserDict 内部的工作方式要求你手工地调用它的 __init__ 方法去正确初始化它的内部数据结构。dict 并不这样工作，它不是一个封装所以不需要明确的初始化。

例 5.16. UserDict 中更多的专用方法

    def __repr__(self): return repr(self.data)     
    def __cmp__(self, dict):                       
        if isinstance(dict, UserDict):            
            return cmp(self.data, dict.data)      
        else:                                     
            return cmp(self.data, dict)           
    def __len__(self): return len(self.data)       
    def __delitem__(self, key): del self.data[key] 

	__repr__ 是一个专用的方法，在当调用 repr(instance) 时被调用。repr 函数是一个内置函数，它返回一个对象的字符串表示。它可以用在任何对象上，不仅仅是类的实例。你已经对 repr 相当熟悉了，尽管你不知道它。在交互式窗口中，当你只敲入一个变量名，接着按ENTER，Python 使用 repr 来显示变量的值。自已用一些数据来创建一个字典 d ，然后用 print repr(d) 来看一看吧。
	__cmp__ 在比较类实例时被调用。通常，你可以通过使用 == 比较任意两个 Python 对象，不只是类实例。有一些规则，定义了何时内置数据类型被认为是相等的，例如，字典在有着全部相同的关键字和值时是相等的。对于类实例，你可以定义 __cmp__ 方法，自已编写比较逻辑，然后你可以使用 == 来比较你的类，Python 将会替你调用你的 __cmp__ 专用方法。
	__len__ 在调用 len(instance) 时被调用。len 是一个内置函数，可以返回一个对象的长度。它可以用于任何被认为理应有长度的对象。字符串的 len 是它的字符个数；字典的 len 是它的关键字的个数；列表或序列的 len 是元素的个数。对于类实例，定义 __len__ 方法，接着自已编写长度的计算，然后调用 len(instance)，Python 将替你调用你的 __len__ 专用方法。
	__delitem__ 在调用 del instance[key] 时调用 ，你可能记得它作为从字典中删除单个元素的方法。当你在类实例中使用 del 时，Python 替你调用 __delitem__ 专用方法。

例 5.17. 类属性介绍

class MP3FileInfo(FileInfo):
    "store ID3v1.0 MP3 tags"
    tagDataMap = {"title"   : (  3,  33, stripnulls),
                  "artist"  : ( 33,  63, stripnulls),
                  "album"   : ( 63,  93, stripnulls),
                  "year"    : ( 93,  97, stripnulls),
                  "comment" : ( 97, 126, stripnulls),
                  "genre"   : (127, 128, ord)}

>>> import fileinfo
>>> fileinfo.MP3FileInfo            
<class fileinfo.MP3FileInfo at 01257FDC>
>>> fileinfo.MP3FileInfo.tagDataMap 
{'title': (3, 33, <function stripnulls at 0260C8D4>), 
'genre': (127, 128, <built-in function ord>), 
'artist': (33, 63, <function stripnulls at 0260C8D4>), 
'year': (93, 97, <function stripnulls at 0260C8D4>), 
'comment': (97, 126, <function stripnulls at 0260C8D4>), 
'album': (63, 93, <function stripnulls at 0260C8D4>)}
>>> m = fileinfo.MP3FileInfo()      
>>> m.tagDataMap
{'title': (3, 33, <function stripnulls at 0260C8D4>), 
'genre': (127, 128, <built-in function ord>), 
'artist': (33, 63, <function stripnulls at 0260C8D4>), 
'year': (93, 97, <function stripnulls at 0260C8D4>), 
'comment': (97, 126, <function stripnulls at 0260C8D4>), 
'album': (63, 93, <function stripnulls at 0260C8D4>)}

	MP3FileInfo 是类本身，不是任何类的特别实例。
	tagDataMap 是一个类属性：字面的意思，一个类的属性。它在创建任何类实例之前就有效了。
	类属性既可以通过直接对类的引用，也可以通过对类的任意实例的引用来使用。

例 5.18. 修改类属性

>>> class counter:
...     count = 0                     
...     def __init__(self):
...         self.__class__.count += 1 
...     
>>> counter
<class __main__.counter at 010EAECC>
>>> counter.count                     
0
>>> c = counter()
>>> c.count                           
1
>>> counter.count
1
>>> d = counter()                     
>>> d.count
2
>>> c.count
2
>>> counter.count
2

	count 是 counter 类的一个类属性。
	__class__ 是每个类实例的一个内置属性 (也是每个类的)。它是一个类的引用，而 self 是一个类 (在本例中，是 counter 类) 的实例。
	因为 count 是一个类属性，它可以在我们创建任何类实例之前，通过直接对类引用而得到。
	创建一个类实例会调用 __init__ 方法，它会给类属性 count 加 1。这样会影响到类自身，不只是新创建的实例。
	创建第二个实例将再次增加类属性 count。注意类属性是如何被类和所有类实例所共享的。

例 5.19. 尝试调用一个私有方法

>>> import fileinfo
>>> m = fileinfo.MP3FileInfo()
>>> m.__parse("/music/_singles/kairo.mp3") 
Traceback (innermost last):
  File "<interactive input>", line 1, in ?
AttributeError: 'MP3FileInfo' instance has no attribute '__parse'

如果你试图调用一个私有方法，Python 将引发一个有些误导的异常，宣称那个方法不存在。当然它确实存在，但是它是私有的，所以在类外是不可使用的。严格地说，私有方法在它们的类外是可以访问的，只是不容易 处理。在 Python 中没有什么是真正私有的；在内部，私有方法和属性的名字被忽然改变和恢复，以致于使得它们看上去用它们给定的名字是无法使用的。你可以通过 _MP3FileInfo__parse 名字来使用 MP3FileInfo 类的 __parse 方法。知道了这个方法很有趣，然后要保证决不在真正的代码中使用它。私有方法由于某种原因而私有，但是像其它很多在 Python 中的东西一样，它们的私有化基本上是习惯问题，而不是强迫的。

例 6.1. 打开一个不存在的文件

>>> fsock = open("/notthere", "r")      
Traceback (innermost last):
  File "<interactive input>", line 1, in ?
IOError: [Errno 2] No such file or directory: '/notthere'
>>> try:
...     fsock = open("/notthere")       
... except IOError:                     
...     print "The file does not exist, exiting gracefully"
... print "This line will always print" 
The file does not exist, exiting gracefully
This line will always print

	使用内置 open 函数，我们可以试着打开一个文件来读取 (在下一节有关于 open 的更多内容)。但是那个文件不存在，所以这样就引发 IOError 异常。因为我们没有提供任何显式的对 IOError 异常的检查，Python 仅仅打印出某个关于发生了什么的调试信息，然后终止。
	我们试图打开同样不存在的文件，但是这次我们在一个 try...except 内来执行它。
	当 open 方法引发 IOError 异常时，我们已经准备好处理它了。except IOError: 行捕捉异常，接着执行我们自已的代码块，这个代码块在本例中只是打印出更令人愉快的错误信息。
	一旦异常被处理了，处理通常在 try...except 块之后的第一行继续进行。注意这一行将总是打印出来，无论异常是否发生。如果在你的根目录下确实有一个叫 notthere 的文件，对 open 的调用将成功，except 子句将忽略，并且最后一行仍将执行。

例 6.3. 打开文件

>>> f = open("/music/_singles/kairo.mp3", "rb") 
>>> f                                           
<open file '/music/_singles/kairo.mp3', mode 'rb' at 010E3988>
>>> f.mode                                      
'rb'
>>> f.name                                      
'/music/_singles/kairo.mp3'

	open 方法可以接收三个参数：文件名、模式和缓冲区参数。只有第一个参数 (文件名) 是必须的；其它两个是可选的。如果没有指定，文件以文本方式打开。这里我们以二进制方式打开文件进行读取。(print open.__doc__ 会给出所有可能模式的很好的解释。)
	open 函数返回一个对象 (到现在为止，这一点应该不会使你感到吃惊)。一个文件对象有几个有用的属性。
	文件对象的 mode 属性告诉你文件以何种模式被打开。
	文件对象的 name 属性告诉你文件对象所打开的文件名。