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>
>>> FunctionType</type>

##如果不用模組名稱而直接使用其中的名字則出錯. 所以列印:

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

#現在看看另一個導入模組中名字的語法:

from 模組名import 名字

或用

from 模組名稱import *

#例如:

>>> from types import FunctionType

##這樣導入的名字就可以不透過模組名稱直接使用. 如:

>>> FunctionType
<type></type>

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></class>

建立了類別的實例後. 我們不用擔心回收的問題. 垃圾回收會根據引用計數自動銷毀不用的物件.

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物件及物件導向技術相關文章請關注PHP中文網！