Python 研究(Dive Into Python)

lastwinner

5.1. 概览
下面是一个完整的，可运行的 Python 程序。请阅读模块、类和函数的 doc strings，可以大概了解这个程序所做的事情和工作情况。象平时一样，不用担心你不理解的东西，这就是本章其它部分将告诉你的内容。

例 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 文件目录。

下面就是从我的机器上得到的输出。你的输出将不一样，除非，由于某些令人吃惊的巧合，你与我有着共同的音乐品味。

album=
artist=Ghost in the Machine
title=A Time Long Forgotten (Concept
genre=31
name=/music/_singles/a_time_long_forgotten_con.mp3
year=1999
comment=http://mp3.com/ghostmachine

album=Rave Mix
artist=***DJ MARY-JANE***
title=HELLRAISER****Trance from Hell
genre=31
name=/music/_singles/hellraiser.mp3
year=2000
comment=http://mp3.com/DJMARYJANE

album=Rave Mix
artist=***DJ MARY-JANE***
title=KAIRO****THE BEST GOA
genre=31
name=/music/_singles/kairo.mp3
year=2000
comment=http://mp3.com/DJMARYJANE

album=Journeys
artist=Masters of Balance
title=Long Way Home
genre=31
name=/music/_singles/long_way_home1.mp3
year=2000
comment=http://mp3.com/MastersofBalan

album=
artist=The Cynic Project
title=Sidewinder
genre=18
name=/music/_singles/sidewinder.mp3
year=2000
comment=http://mp3.com/cynicproject

album=Digitosis@128k
artist=VXpanded
title=Spinning
genre=255
name=/music/_singles/spinning.mp3
year=2000
comment=http://mp3.com/artists/95/vxp

lastwinner

5.2. 使用 from module import 导入模块
Python 有两种导入模块的方法。两种都有用，你应该知道什么时候使用哪一种方法。一种方法， import module，你已经在第 2.4 节 “万物皆对象”看过了。另一种方法完成同样的事情，但是它与第一种有着细微但重要的区别。

下面是 from module import 的基本语法：


from UserDict import UserDict
它与你所熟知的 import module 语法很相似，但是有一个重要的区别：被导入模块 types 的属性和方法被直接导入到局部名字空间去了，所以它们可以直接使用，而不需要加上模块名的限定。你可以导入独立的项或使用 from module import * 来导入所有东西。


Python 中的 from module import * 象 Perl 中的 use module ；Python 中的 import module 象 Perl 中的 require module 。

Python 中的 from module import * 象 Java 中的 import module.* ；Python 中的 import module 象 Java 中的 import module 。

例 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 无关了。

什么时候你应该使用 from module import？

如果你要经常访问模块的属性和方法，且不想一遍又一遍地敲入模块名，使用 from module import。
如果你想要有选择地导入某些属性和方法，而不想要其它的，使用 from module import。
如果模块包含的属性和方法与你的某个模块同名，你必须使用 import module 来避免名字冲突。
除了这些情况，剩下的只是风格问题了，你会看到用两种方式编写的 Python 代码。


尽量少用 from module import * ，因为判定一个特殊的函数或属性是从哪来的有些困难，并且会造成调试和重构都更困难。

lastwinner

进一步阅读关于模块导入技术

• eff-bot 有更多关于 import module vs. from module import 的论述。
• Python Tutorial 讨论了高级的导入技术，包括 from module import *。

lastwinner

5.3. 类的定义
5.3.1. 初始化并开始类编码
5.3.2. 了解何时去使用 self 和 __init__
Python 是完全面向对象的：你可以定义自已的类，从自已的或内置的类继承，然后从你定义的类创建实例。

在 Python 中定义类很简单。就象定义函数，没有单独的接口定义。只要定义类，然后就可以开始编码。Python 类以保留字 class 开始，后面跟着类名。从技术上讲，有这些就够了，因为一个类并非必须从其它类继承。

例 5.3. 最简单的 Python 类

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


在 Python 中的 pass 语句就象 Java 或 C 中的大括号空集 ({})。

当然，实际上大多数的类都是从其它的类继承来的，并且它们会定义自已的类方法和属性。但是就象你刚才看到的，除了名字以外，类没有什么必须要具有的。特别是，C++ 程序员可能会感到奇怪，Python 的类没有显示的构造函数和析构函数。Python 类的确存在与构造函数相似的东西： __init__ 方法。

例 5.4. 定义 FileInfo 类

from UserDict import UserDict

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


在 Python 中，类的基类只是简单地列在类名后面的小括号里。不象在 Java 中有一个特殊的象 extends 的关键字。

Python 支持多重继承。在类名后面的小括号中，你可以列出许多你想要的类名，以逗号分隔。

lastwinner

5.3.1. 初始化并开始类编码
本例演示了使用 __init__ 方法来进行 FileInfo 类的初始化。

例 5.5. 初始化 FileInfo Class

class FileInfo(UserDict):
    "store file metadata"              
    def __init__(self, filename=None):     类也可以 （并且 应该） 有 doc strings ，就象方法和函数一样。
  __init__ 在类的实例创建后被立即调用。它可能会引诱你称之为类的构造函数，但这种说法并不正确。说它引诱，是因为它看上去象（按照习惯， __init__ 是类中第一个定义的方法），行为也象（在一个新创建的类实例中，它是首先被执行的代码），并且叫起来也象（“init”当然意味着构造的本性）。说它不正确，是因为对象在调用 __init__ 时已经被构造出来了，你已经有了一个对类的新实例的有效引用。但 __init__ 是在 Python 中你可以得到的最接近构造函数的东西，并且它也扮演着非常相同的角色。
  每个类方法的第一个参数，包括 __init__，都是指向类的当前实例的引用。按照习惯这个参数总是被称为 self。在 __init__ 方法中，self 指向新创建的对象；在其它的类方法中，它指向方法被调用的类实例。尽管当定义方法时你需要明确指定 self，但在调用方法时，你不用指定它，Python 会替你自动加上的。
  __init__ 方法可以接受任意个数的参数，就象函数一样，参数可以用缺省值定义，可以设置成对于调用者可选。在本例中， filename 有一个缺省值 None，即 Python 的空值。


习惯上，任何 Python 类方法的第一个参数（对当前实例的引用）都叫做 self。这个参数扮演着 C++ 或 Java 中的保留字 this 的角色，但 self 在 Python 中并不是一个保留字，它只是一个命名习惯。虽然如此，也请除了 self 之外不要使用其它的名字，这是一个非常坚固的习惯。

例 5.6. 编写 FileInfo 类

class FileInfo(UserDict):
    "store file metadata"
    def __init__(self, filename=None):
        UserDict.__init__(self)        
        self["name"] = filename        
                                         一些伪面向对象语言，象 Powerbuilder 有一种“扩展”构造函数和其它事件的概念，即父类的方法在子类的方法执行前被自动调用。Python 不是这样，你必须显示地调用在父类中的适合方法。
  我告诉过你，这个类象字典一样工作，那么这里就是第一个印象。我们将参数 filename 赋值给对象 name 关键字，作为它的值。
  注意 __init__ 方法从不返回一个值。

lastwinner

5.3.2. 了解何时去使用 self 和 __init__
当定义你自已的类方法时，你 必须 明确将 self 作为每个方法的第一个参数列出，包括 __init__。当从你的类中调用一个父类的一个方法时，你必须包括 self 参数。但当你从类的外部调用你的类方法时，你不必对 self 参数指定任何值；你完全将其忽略，而 Python 会自动地替你增加实例的引用。我知道刚开始这有些混乱，它并不是自相矛盾的，因为它依靠于一个你还不了解的区别（在绑定与非绑定方法之间），故看上去是矛盾的。

噢。我知道有很多知识需要吸收，但是你要掌握它。所有的 Python 类以相同的方式工作，所以一旦你学会了一个，就是学会了全部。如果你忘了别的任何事，也要记住这件事，因为我认定它会让你出错：


__init__ 方法是可选的，但是一旦你定义了，就必须记得显示调用父类的 __init__ 方法（如果它定义了的话）。这样更是正确的：无论何时子类想扩展父类的行为，后代方法必须在适当的时机，使用适当的参数，显式调用父类方法。

lastwinner

进一步阅读关于 Python 类

• Learning to Program 有优雅的 类的介绍。
• How to Think Like a Computer Scientist 展示了如何 使用类来实现复合数据类型模型。
• Python Tutorial 深入考虑了 类、名字空间和继承。
• Python Knowledge Base 回答了 关于类的常见问题。

lastwinner

5.4. 类的实例化
5.4.1. 垃圾回收
在 Python 中对类进行实例化很直接。为了对类进行实例化，只要调用类，好象它是一个函数，传入定义在 __init__ 方法中的参数。返回值将是新创建的对象。

例 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 自动添加的）。


在 Python 中，创建类的实例只要调用一个类，仿佛它是一个函数就行了。不象 C++ 或 Java 有一个明确的 new 操作符。

lastwinner

5.4.1. 垃圾回收
如果说创建一个新的实例是容易的，那么销毁它们甚至更容易。通常，不需要明确地释放实例，因为当指派给它们的变量超出作用域时，它们会被自动地释放。内存泄漏在 Python 中很少见。

例 5.8. 尝试实现内存泄漏
>>> def leakmem():
...     f = fileinfo.FileInfo('/music/_singles/kairo.mp3')
...     
>>> for i in range(100):
...     leakmem()                                            每次 leakmem 函数被调用，你创建了 FileInfo 的一个实例，将其赋给变量 f，这个变量是函数内的一个局部变量。然后函数结束没有释放 f，所以你可能认为有内存泄漏，但是你错了。当函数结束时，局部变量 f 超出了作用域。在这个地方，不再有任何对 FileInfo 新创建实例的引用（因为除了 f 我们从未将其赋值给其它变量），所以 Python 替我们销毁掉实例。
  不管我们调用 leakmem 函数多少次，决不会泄漏内存，因为每一次，Python 将在从 leakmem 返回前销毁掉新创建的 FileInfo 类实例。

对于这种垃圾收集的方式，技术上的术语叫做“引用计数”。Python 维护着对每个实例的引用列表。在上面的例子中，只有一个 FileInfo 的实例引用：局部变量 f。当函数结束时，变量 f 超出作用域，所以引用计数降为 0，则 Python 自动销毁掉实例。

在 Python 的以前版本中，存在引用计数失败的情况，这样 Python 不能在后面进行清除。如果你创建两个实例，它们相互引用（例如，双重链表，每一个结点有都一个指向列表中前一个和后一个结点的指针），任一个实例都不会被自动销毁，因为 Python （正确）认为对于每个实例都存在一个引用。 Python 2.0 有一种额外的垃圾回收方式，叫做“标记后清除”，它足够聪明，可以正确地清除循环引用。

作为曾经读过哲学专业的一员，让我感到困惑的是，当没有人对事物进行观察时，它们就消失了，但是这确实是在 Python 中所发生的。通常，你可以完全忘记内存管理，让 Python 在后面进行清理。

lastwinner

进一步阅读

• Python Library Reference 总结了 象 __class__ 之类的内置属性。
• Python Library Reference 提供了 gc 模块的文档，此模块给予你对 Python 的垃圾回收的底层控制权。