python对象及面向对象技术详解

本文实例讲述了python对象及面向对象技术。分享给大家供大家参考，具体如下：

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("{post.content}", "").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

2 使用 from module import 导入模块

我们以前学的导入模块是用下边的语法:

import 模块名

这样在需要使用该模块中的东西时. 要通过 模块名.XXX 的形式. 例如:

    >>> import types
    >>> types.FunctionType
    <type 'function'>
    >>> FunctionType

如果不用模块名而直接使用其中的名字则出错. 所以打印:

    Traceback (most recent call last):
     File "<interactive input>", line 1, in <module>
    NameError: name 'FunctionType' is not defined

现在看看另一种导入模块中名字的语法:

from 模块名 import 名字

或者用

from 模块名 import *

例如:

    >>> from types import FunctionType

这样导入的名字就可以不通过模块名而直接使用. 如:

    >>> FunctionType
    <type 'function'>

3 类的定义

定义类的语法:

class 类名:
pass

或者

class 类名(基类列表) :
pass

其中的 pass 是Python的关键字. 表示什么也不做.

类也可以有类文档. 如果有的话. 他应该是类定义中的第一个东西. 如:

    class A(B) :
      " this is class A. "

类的构造函数为:

    __init__

不过. 准确的说. 这只能算是创建该类对象后. 自动执行的方法. 当执行这个函数时. 对象已初始化了.

例如:

    class A(B) :
      "this is class A. "
      def __init__ (self):
        B.__init__(self)

这里为类A 定义了一个构造方法. 并且在其中调用了基类B的构造方法.

要注意的是. 在Python中. 构造派生类时. 并不会"自动"的调用基类的构造方法. 需要的话必须显式写出.

所有的类方法. 第一个参数都是用来接收this指针. 习惯上这个参数的名字是 self.

调用时不要传递这个参数. 它会自动被加上的.

但是在象上边的构造函数中. 调用基类的__init()时. 这个参数必须显式给出.

4 类的实例化

实例化一个类和其它语言相似. 只把它的类名当作一个函数调用就行了. 而没有其它语言的new之类.

类名(参数表)

其中参数表中不必给出init的第一个参数self.

例如:

a = A()

我们可以通过类或类的实例查看该类的文档. 这通过它们的doc属性. 如:

    >>> A.__doc__
    'this is class A. '
    >>> a.__doc__
    'this is class A. '

我们也可以通过类的实例来得到它的类. 这通过它的class属性. 如:

    >>> a.__class__
    <class __main__.A at 0x011394B0>

创建了类的实例后. 我们不用担心回收的问题. 垃圾回收会根据引用计数自动销毁不用的对象.

Python中. 类的数据成员也没有专门的声明语句. 而是在赋值的时候"突然产生"的. 例如:

    class A :
      def __init__(self) :
        self.data = []

这时. 就自动让data作为类A的成员了.

之后在类的定义内. 要使用类中的成员变量或成员方法. 都要用 self.名字 来限定.

所以一般要产生数据成员. 在任何方法中对 self.成员名字 赋值即可.

不过. 在init方法中对所有数据属性都赋一个初始值. 是一个好习惯.

Python不支持函数重载.

这里再说说代码缩进. 实际上. 如果一个代码块只有一句. 可以直接放在 冒号 后边. 而不需要换行缩进格式.

6 专用类方法

和普通的方法不同. 在类中定义专用方法后. 并不要你显式的调用它们. 而是在某些时候有Python自动调用.

获得和设置数据项.

这需要在类中定义 getitem 和 setitem 方法.

例如:

    >>> class A:
    ... def __init__(self):
    ...  self.li = range(5)
    ... def __getitem__(self, i):
    ...  return self.li[-i]
    ...
    >>> a = A()
    >>> print a[1]

这里的 a[1] 就调用了 getitem 方法. 它等于 a.getitem(1)

与getitem方法类似的有 setitem

例如在上边的A类中定义:

    def __setitem__(self, key, item):
      self.li[key] = item

然后调用这个方法如下:

a[1] = 0 它等于调用 a.setitem(1, 0)

7 高级专用类方法

和 getitem setitem 类似. 还有一些特殊的专用函数. 如下:

    def __repr__(self): return repr(self.li)

这个专用方法用来本对象的字符串表示. 调用它是通过内置函数repr(). 如

    repr(a)

这个repr()可以作用在任何对象上.

实际上. 在交互窗口中. 只要输入 变量名 回车. 就用repr显示变量的值.

    def __cmp__(self, x):
      if isinstance(x, A): return cmp(self.li, x.li)

它用来比较两个实例 self 和 x 是否相等. 调用它时如下:

    a = A()
    b = A()
    a == b

这里比较 a和b是否相等. 和调用 a.cmp(b) 一样

    def __len__(self): return len(self.li)

它用来返回对象的长度. 在使用 len(对象) 的时候会调用它.
用它可以指定一个你希望的逻辑长度值.

    def __delitem__(self, key): del self.li[key]

在调用 del 对象[key] 时会调用这个函数.

8 类属性

类属性指的是象c++中静态成员一类的东西.

Python中也可以有类属性. 例如:

    class A :
      l = [1, 2, 3]

可以通过类来引用(修改). 或者通过实例来引用(修改). 如:

    A.l

或

    a.__class__.l

9 私有函数

Python中也有"私有"这个概念:

私有函数不可以从它们的模块外边被调用.
私有类方法不能从它们的类外边被调用.
私有属性不能从它们的类外边被访问.

Python中只有私有和公有两种. 没有保护的概念. 而区分公有还是私有是看函数. 类方法. 类属性的名字.

私有的东西的名字以 开始. (但前边说的专用方法(如getitem__)不是私有的).

更多关于Python相关内容感兴趣的读者可查看本站专题：《Python面向对象程序设计入门与进阶教程》、《Python文件与目录操作技巧汇总》、《Python图片操作技巧总结》、《Python数据结构与算法教程》、《Python Socket编程技巧总结》、《Python函数使用技巧总结》、《Python字符串操作技巧汇总》、《Python编码操作技巧总结》及《Python入门与进阶经典教程》

希望本文所述对大家Python程序设计有所帮助。