本文深入分析了Python面向?qū)ο蟪绦蛟O(shè)計(jì)OOP。分享給大家供大家參考，具體如下：

下面是一個(gè)關(guān)于OOP的實(shí)例，模塊文件為person.py

# File person.py(start)
class Person:
  def __init__(self, name, job=None, pay=0):
    self.name = name
    self.job = job
    self.pay = pay
  def last_name(self):
    return self.name.split()[-1]
  def give_raise(self, percent):
    self.pay = int(self.pay * (1+percent))
    print('total percent:%f' % percent)
  def __str__(self):
    return '[Person: %s, %s]' % (self.name, self.pay)
class Manager(Person):
  # 這是一種不太好的方法重載的方法，實(shí)際應(yīng)用中我們采用下面的方法
  def give_raise(self, percent, bonus=.1):
    self.pay = int(self.pay * (1+percent+bonus))
  # 這個(gè)方法利用了這樣的一個(gè)事實(shí)：類(lèi)方法總是可以在一個(gè)實(shí)例中調(diào)用。
  # 其實(shí)常規(guī)的實(shí)例調(diào)用，也是轉(zhuǎn)換為類(lèi)的調(diào)用
  # instance.method(args...) 由Python自動(dòng)地轉(zhuǎn)換為 class.method(instance,args...)
  # 所以要記得直接通過(guò)類(lèi)進(jìn)行調(diào)用時(shí)，必須手動(dòng)傳遞實(shí)例，這里就是self參數(shù)
  # 而且不能寫(xiě)成self.give_raise，這樣會(huì)導(dǎo)致循環(huán)調(diào)用
  #
  # 那么為什么采用這種形式呢？因?yàn)樗鼘?duì)未來(lái)的代碼的維護(hù)意義重大，因?yàn)間ive_raise現(xiàn)在
  # 只在一個(gè)地方，即Person的方法，將來(lái)需要修改的時(shí)候，我們只需要修改一個(gè)版本
  def give_raise(self, percent, bonus=.1):
    Person.give_raise(self, percent+bonus)
if __name__ == '__main__':
  # self-test code
  bob = Person('Bob Smith')
  sue = Person('Sue Jones', job='dev', pay=100000)
  print(bob)
  print(sue)
  print(bob.last_name(), sue.last_name())
  sue.give_raise(.1)
  print(sue)
  print('-'*20)
  tom = Manager('Tom Jones', 'mgr', 50000)
  tom.give_raise(.1)
  print(tom.last_name())
  print(tom)
  print('--All three--')
  for obj in (bob, sue, tom):
    obj.give_raise(.1)
    print(obj)

這個(gè)示例定義了Person類(lèi)，并且Person類(lèi)的構(gòu)造函數(shù)采用了默認(rèn)關(guān)鍵字參數(shù)，重載了__str__方法用以print輸出，定義了得到last_name的方法，定義了give_raise漲工資方法。類(lèi)Manager繼承自Person，Manager重新定義了自己的give_raise方法，獲得額外的bonus=0.1的獎(jiǎng)金。

在代碼最后，寫(xiě)了自測(cè)試的代碼if __name__ == '__main__',用以測(cè)試。輸出如下：

[Person: Bob Smith, 0]
[Person: Sue Jones, 100000]
Smith Jones
total percent:0.100000
[Person: Sue Jones, 110000]
--------------------
total percent:0.200000
Jones
[Person: Tom Jones, 60000]
--All three--
total percent:0.100000
[Person: Bob Smith, 0]
total percent:0.100000
[Person: Sue Jones, 121000]
total percent:0.200000
[Person: Tom Jones, 72000]

這里也可以給Manager增加自己獨(dú)有的方法。

定制構(gòu)造函數(shù)

現(xiàn)在的代碼可以正常工作，但是，如果仔細(xì)研究會(huì)發(fā)現(xiàn)，當(dāng)我們創(chuàng)建Manager對(duì)象的時(shí)候，必須為它提供一個(gè)mgr工作名稱(chēng)似乎沒(méi)有意義：這已經(jīng)由類(lèi)自身暗示了。

所以，為了改善這點(diǎn)，我們要重新定義Manager中的__init__方法，從而提供mgr字符串，而且和give_raise的定制一樣，通過(guò)類(lèi)名的調(diào)用來(lái)運(yùn)行Person中最初的__init__。

def __init__(self, name, pay):
    Person.__init__(self, name, 'mgr', pay)

那么之后的實(shí)例化就變成了：

tom = Manager('Tom Jones', 50000)

OOP比我們認(rèn)為的簡(jiǎn)單

這是Python的OOP機(jī)制中幾乎所有重要的概念：

1. 實(shí)例創(chuàng)建——填充實(shí)例屬性
2. 行為方法——在類(lèi)方法中封裝邏輯
3. 運(yùn)算符重載——為打印這樣的內(nèi)置操作提供行為
4. 定制行為——重新定義子類(lèi)中的方法以使其特殊化
5. 定制構(gòu)造函數(shù)——為超類(lèi)步驟添加初始化邏輯。

組合類(lèi)的其他方式

有時(shí)候，我們可以以其他的方式組合類(lèi)。例如，一種常用的編碼模式是把對(duì)象彼此嵌套以組成復(fù)合對(duì)象，而不是繼承。如下的替代方法使用__getattr__運(yùn)算符重載方法來(lái)攔截未定義屬性的訪問(wèn)。這時(shí)候，我們的代碼如下：

class Person:
  ...same...
class Manager():
  def __init__(self, name, pay):
    self.person = Person(name, 'mgr', pay)
  def give_raise(self, percent, bonus=.1):
    self.person.give_raise(percent+bonus)
  def __getattr__(self, attr):
    return getattr(self.person, attr)
  def __str__(self):
    return str(self.person)
if __name__ == '__main__':
  ...same...

實(shí)際上，這個(gè)Manager替代方案是一種叫做委托的常用代碼模式的一個(gè)代表，委托是一種基于符合的結(jié)構(gòu)，它管理一個(gè)包裝的對(duì)象并且把方法調(diào)用傳遞給它。

這里Manager不是一個(gè)真正的Person，因此，我們必須增加額外的代碼為嵌入的對(duì)象分派方法，比如像__str__這樣的運(yùn)算符重載方法必須重新定義。所以它需要的代碼量增加，對(duì)于這個(gè)例子來(lái)說(shuō)，沒(méi)有哪個(gè)明智的Python程序員會(huì)按照這種方式組織代碼，但是，當(dāng)嵌入的對(duì)象比直接定制隱藏需要與容器之間有更多有限的交互時(shí)，對(duì)象嵌入以及基于其上的設(shè)計(jì)模式還是很適合的。

下述代碼假設(shè)Department可能聚合其他對(duì)象，以便將它們當(dāng)做一個(gè)集合對(duì)待。

class Department:
  def __init__(self, *args):
    self.members = list(args)
  def add_member(self, person):
    self.members.append(person)
  def give_raise(self, percent):
    for person in self.members:
      person.give_raise(percent)
  def show_all(self):
    for person in self.members:
      print(person)
development = Department(bob,sue)
  development.add_member(tom)
  development.give_raise(.1)
  development.show_all()

這里的代碼使用了繼承和復(fù)合——Department是嵌入并控制其他對(duì)象的聚合的一個(gè)復(fù)合體，但是，嵌入的Person和Manager對(duì)象自身使用繼承來(lái)定制。作為另一個(gè)例子，一個(gè)GUI可能類(lèi)似地使用繼承來(lái)定制標(biāo)簽和按鈕的行為或外觀，但也會(huì)復(fù)合以構(gòu)建嵌入的掛件（如輸入表單、計(jì)算器和文本編輯器）的一個(gè)更大的包。

使用內(nèi)省類(lèi)工具

我們定制構(gòu)造函數(shù)之后的Manager類(lèi)還有幾點(diǎn)小問(wèn)題如下：

1. 打印的時(shí)候，Manager會(huì)把他標(biāo)記為Person。如果能夠用最確切（也就是說(shuō)最低層）的類(lèi)來(lái)顯示對(duì)象，這可能會(huì)更準(zhǔn)確些。
2. 其次，當(dāng)前的顯示格式只是顯示了包含在__str__中的屬性，而沒(méi)有考慮未來(lái)的目標(biāo)。例如，我們無(wú)法通過(guò)Manager的構(gòu)造函數(shù)驗(yàn)證tom工作名已經(jīng)正確地設(shè)置為mgr，因?yàn)槲覀優(yōu)镻erson編寫(xiě)的__str__沒(méi)有打印出這一字段。更糟糕的是，如果我們改變了在__init__中分配給對(duì)象的屬性集合，那么還必須記得也要更新__str__以顯示新的名字，否則，將無(wú)法隨著時(shí)間的推移而同步。

我們可以使用Python的內(nèi)省工具來(lái)解決這兩個(gè)問(wèn)題，它們是特殊的屬性和函數(shù)，允許我們?cè)L問(wèn)對(duì)象實(shí)現(xiàn)的一些內(nèi)部機(jī)制。例如，在我們的代碼中，有兩個(gè)鉤子可以幫助我們解決問(wèn)題：

1. 內(nèi)置的instance.__class__屬性提供了一個(gè)從實(shí)例到創(chuàng)建它的類(lèi)的鏈接。類(lèi)反過(guò)來(lái)有一個(gè)__name__，還有一個(gè)__bases__序列，提供了超類(lèi)的訪問(wèn)。我們使用這些來(lái)打印創(chuàng)建的一個(gè)實(shí)例的類(lèi)的名字，而不是通過(guò)硬編碼來(lái)做到。
2. 內(nèi)置的object.__dict__屬性提供了一個(gè)字典，帶有一個(gè)鍵/值對(duì)，以便每個(gè)屬性都附加到一個(gè)命名空間對(duì)象（包括模塊、類(lèi)和實(shí)例）。由于它是字典，因此我們可以獲取鍵的列表、按照鍵來(lái)索引、迭代其值等等。我們使用這些來(lái)打印出任何實(shí)例的每個(gè)屬性，而不是在定制顯示中硬編碼。

下面是這些工具在交互模式下的實(shí)際使用情形：

>>> from person import Person
>>> bob = Person('Bob Smith')
>>> print(bob)
[Person: Bob Smith, 0]
>>> bob.__class__
<class 'person.Person'>
>>> bob.__class__.__name__
'Person'
>>> list(bob.__dict__.keys())
['name', 'pay', 'job']
>>> for key in bob.__dict__:
...   print(key,'=>',bob.__dict__[key])
...
name => Bob Smith
pay => 0
job => None
>>> for key in bob.__dict__:
...   print(key,'=>',getattr(bob,key))
...
name => Bob Smith
pay => 0
job => None

一種通用的顯示工具

新打開(kāi)一個(gè)文件，并編寫(xiě)如下代碼：它是一個(gè)新的、獨(dú)立的模塊，名為classtools.py，僅僅實(shí)現(xiàn)了這樣一個(gè)類(lèi)。由于其__str__，print重載用于通用的內(nèi)省工具，它將會(huì)對(duì)任何實(shí)例有效，不管實(shí)例的屬性集合是什么。并且由于這是一個(gè)類(lèi)，所以它自動(dòng)變成一個(gè)公用的工具：得益于繼承，他可以混合到想要使用它顯示格式的任何類(lèi)中。作為額外的好處，如果我們想要改變實(shí)例的顯示，只需要修改這個(gè)類(lèi)即可。

# File classtools.py
"""Assorted class utilities and tools"""
class AttrDisplay:
  """
  Provides an inheritable print overload method that displays
  instances with their class names and a name-value pair for
  each attribute stored on the instance itself(but not attrs
  inherited from its classes).Can be mixed into any class,
  and will work on any instance.
  """
  def gatherAttrs(self):
    attrs = []
    for key in sorted(self.__dict__):
      attrs.append('%s = %s' % (key,getattr(self,key)))
    return ','.join(attrs)
  def __str__(self):
    return '[%s:%s]' % (self.__class__.__name__, self.gatherAttrs())
if __name__ == '__main__':
  class TopTest(AttrDisplay):
    count = 0
    def __init__(self):
      self.attr1 = TopTest.count
      self.attr2 = TopTest.count + 1
      TopTest.count += 2
  class SubTest(TopTest):
    pass
  x, y = TopTest(), SubTest()
  print(x)
  print(y)

注意這里的文檔字符串，作為通用的工具，我們需要添加一些功能來(lái)產(chǎn)生文檔。

這里定義的__str__顯示了實(shí)例的類(lèi)，及其所有的屬性名和值，按照屬性名排序。

[TopTest:attr1 = 0,attr2 = 1]
[SubTest:attr1 = 2,attr2 = 3]

工具類(lèi)的命名考慮

最后一點(diǎn)需要考慮的是，由于classtools模塊中的AttrDisplayz類(lèi)旨在和其他任意類(lèi)混合的通用性工具，所以我們必須注意與客戶(hù)類(lèi)潛在的無(wú)意的命名沖突。如果一個(gè)子類(lèi)無(wú)意地自己定義了一個(gè)gatherAttrs名稱(chēng)，它很可能會(huì)破壞我們的類(lèi)。

為了減少這樣的名稱(chēng)沖突的機(jī)會(huì)，Python程序員常常對(duì)于不想做其他用途的方法添加一個(gè)【單個(gè)下劃線】的前綴，在我們這個(gè)例子中就是_gatherAttrs。這不是很可靠，如果一個(gè)子類(lèi)也定義了_gatherAttrs，該如何是好？但是它通常已經(jīng)夠用了，并且對(duì)于類(lèi)內(nèi)部的方法，這是常用的Python命名慣例。

一種更好但是不太常用的方法是，只在方法名前面使用【兩個(gè)下劃線】符號(hào)，__gatherAttrs,Python自動(dòng)擴(kuò)展這樣的名稱(chēng)，以包含類(lèi)的名稱(chēng)，從而使它們變得真正唯一。這一功能通常叫做【偽私有類(lèi)屬性】，將在以后介紹。

首先要使用打印這一通用工具，所需要做的是從其模塊中導(dǎo)入它，使用繼承將其混合到頂層類(lèi)中，并且刪除我們之前編寫(xiě)的更專(zhuān)門(mén)的__str__方法。新的打印重載方法將會(huì)由Person的實(shí)例繼承，Manager的實(shí)例也會(huì)繼承。

下面就是類(lèi)的最終形式：

# File person.py(start)
from classtools import AttrDisplay
class Person(AttrDisplay):
  """
  Create and process person records
  """
  def __init__(self, name, job=None, pay=0):
    self.name = name
    self.job = job
    self.pay = pay
  def last_name(self):
    return self.name.split()[-1]
  def give_raise(self, percent):
    self.pay = int(self.pay * (1+percent))
    print('total percent:%f' % percent)
class Manager(Person):
  """
  A customized Person with special requirements
  """
  def __init__(self, name, pay):
    Person.__init__(self, name, 'mgr', pay)
  def give_raise(self, percent, bonus=.1):
    Person.give_raise(self, percent+bonus)
if __name__ == '__main__':
  # self-test code
  bob = Person('Bob Smith')
  sue = Person('Sue Jones', job='dev', pay=100000)
  print(bob)
  print(sue)
  print(bob.last_name(), sue.last_name())
  sue.give_raise(.1)
  print(sue)
  print('-'*20)
  tom = Manager('Tom Jones', 50000)
  tom.give_raise(.1)
  print(tom.last_name())
  print(tom)

在這個(gè)版本中，也添加了一些新的注釋來(lái)記錄所做的工作和每個(gè)最佳實(shí)踐慣例——使用了功能性描述的文檔字符串和用于簡(jiǎn)短注釋的#?，F(xiàn)在運(yùn)行這段代碼，將會(huì)看到對(duì)象的所有屬性，并且最終的問(wèn)題也解決了：由于AttrDisplay直接從self實(shí)例中提取了類(lèi)名，所有每個(gè)對(duì)象都顯示其最近的（最低的）類(lèi)的名稱(chēng)——tom現(xiàn)在顯示為Manager，而不是Person。

[Person:job = None,name = Bob Smith,pay = 0]
[Person:job = dev,name = Sue Jones,pay = 100000]
Smith Jones
total percent:0.100000
[Person:job = dev,name = Sue Jones,pay = 110000]
--------------------
total percent:0.200000
Jones
[Manager:job = mgr,name = Tom Jones,pay = 60000]

這正是我們所追求的更有用的顯示，我們屬性顯示類(lèi)已經(jīng)變成了一個(gè)【通用工具】，可以通過(guò)繼承將其混合到任何類(lèi)中，從而利用它所定義的顯示格式。

最后：把對(duì)象存儲(chǔ)到數(shù)據(jù)庫(kù)中

我們創(chuàng)建的對(duì)象還不是真正的數(shù)據(jù)庫(kù)記錄，他們只是內(nèi)存中的臨時(shí)對(duì)象，而沒(méi)有存儲(chǔ)到文件這樣更為持久的媒介中。所以，現(xiàn)在要使用Python的一項(xiàng)叫做【對(duì)象持久化】的功能把對(duì)象保存。

Pickle和Shelve

對(duì)象持久化通過(guò)3個(gè)標(biāo)準(zhǔn)的庫(kù)模塊來(lái)實(shí)現(xiàn)，這3個(gè)模塊在Python中都可用：

1. pickle:任意的Python對(duì)象和字節(jié)串之間的序列化
2. dbm:實(shí)現(xiàn)一個(gè)可通過(guò)鍵訪問(wèn)的文件系統(tǒng)，以存儲(chǔ)字符串
3. shelve：使用另兩個(gè)模塊按照把Python對(duì)象存儲(chǔ)在一個(gè)文件中。

在Shelve數(shù)據(jù)庫(kù)中存儲(chǔ)對(duì)象

讓我們編寫(xiě)一個(gè)新的腳本，把類(lèi)的對(duì)象存儲(chǔ)到shelve中。在文本編輯器中，打開(kāi)一個(gè)名為makedb.py的新文件，導(dǎo)入shelve模塊，用一個(gè)外部文件名打開(kāi)一個(gè)新的shelve，把對(duì)象賦給shelve中的鍵，當(dāng)我們操作完畢之后關(guān)閉這個(gè)shelve，因?yàn)橐呀?jīng)做了修改：

# File makedb.py:store Person objects on a shelve database
from person import Person, Manager
import shelve
bob = Person('Bob Smith')
sue = Person('Sue Jones', job='dev', pay='100000')
tom = Manager('Tom Jones', 50000)
db = shelve.open('persondb')
for obj in (bob, sue, tom):
  db[obj.name] = obj
db.close()

注意，這里我們把對(duì)象的名字用作鍵，從而把他們賦給shelve，這么做只是為了方便，在shelve中，鍵可以是任何的字符串，唯一的規(guī)則是，鍵必須是字符串并且是唯一的。這樣，我們就可以針對(duì)每個(gè)鍵只存儲(chǔ)一個(gè)對(duì)象。然而，我們?cè)阪I之下的值可以是幾乎任何類(lèi)型的Python對(duì)象：像字符串、列表和字典這樣的內(nèi)置對(duì)象，用戶(hù)定義的類(lèi)實(shí)例，以及所有這些嵌套式的組合。

運(yùn)行這段代碼，沒(méi)有輸出，意味著他可能有效。

交互式探索shelve

此時(shí)，當(dāng)前的目錄下會(huì)有一個(gè)或多個(gè)真實(shí)的文件，它們的名字都以‘persondb'開(kāi)頭。這就是我們存儲(chǔ)的文件，也就是我們的數(shù)據(jù)庫(kù)，是我們備份或移動(dòng)存儲(chǔ)的時(shí)候需要復(fù)制和轉(zhuǎn)移的內(nèi)容。

在交互式命令窗口中可以查看這些文件：

>>> import glob
>>> glob.glob('person*')
['person.py', 'person2.py', 'persondb.bak', 'persondb.dat', 'persondb.dir']
>>> print(open('persondb.dir').read())
'Tom Jones', (1024, 91)
'Sue Jones', (512, 100)
'Bob Smith', (0, 80)
>>> print(open('persondb.dat','rb').read())
b'\x80\x03cperson\nPerson\nq\x00)\x81q\x01}q\x02(X\x03\x00\x00\x00jobq\x03NX\x03\x00\x00\x00payq\x04K\x00X\x04\x00\x00\x00nameq\x05X\t\x00\x00\x00Bob
...more omitted...

這些內(nèi)容無(wú)法解讀，但是我們可以用常規(guī)的Python語(yǔ)法和開(kāi)發(fā)模式來(lái)處理它，即通過(guò)shelve來(lái)打開(kāi)這些文件。

>>> import shelve
>>> db = shelve.open('persondb')
>>> for key in db:
...   print(key, '=>', db[key])
...
Bob Smith => [Person:job = None,name = Bob Smith,pay = 0]
Tom Jones => [Manager:job = mgr,name = Tom Jones,pay = 50000]
Sue Jones => [Person:job = dev,name = Sue Jones,pay = 100000]
>>> len(db)
3
>>> bob = db['Bob Smith']
>>> bob.last_name()
'Smith'

在這里，為了載入或使用存儲(chǔ)的對(duì)象，我們不一定必須導(dǎo)入Person或Manager類(lèi)。因?yàn)镻ython對(duì)一個(gè)類(lèi)實(shí)例進(jìn)行pickle操作，它記錄了其self實(shí)例屬性，以及實(shí)例所創(chuàng)建于的類(lèi)的名字和類(lèi)的位置。

這種方法的結(jié)果就是，類(lèi)實(shí)例在未來(lái)導(dǎo)入的時(shí)候，會(huì)自動(dòng)地獲取其所有的類(lèi)行為。

更新Shelve中的對(duì)象

現(xiàn)在介紹最后一段腳本，編寫(xiě)一個(gè)程序，在每次運(yùn)行的時(shí)候更新一個(gè)實(shí)例，以此證實(shí)我們的對(duì)象真的是持久化的。如下的updatadb.py打印出數(shù)據(jù)庫(kù)，并且每次把我們所存儲(chǔ)的對(duì)象之一增加一次，跟蹤它的變化：

Bob Smith => [Person:job = None,name = Bob Smith,pay = 0]
Sue Jones => [Person:job = dev,name = Sue Jones,pay = 110000]
Tom Jones => [Manager:job = mgr,name = Tom Jones,pay = 50000]
Tom Jones => [Manager:job = mgr,name = Tom Jones,pay = 50000]
Sue Jones => [Person:job = dev,name = Sue Jones,pay = 121000]
Bob Smith => [Person:job = None,name = Bob Smith,pay = 0]
Bob Smith => [Person:job = None,name = Bob Smith,pay = 0]
Sue Jones => [Person:job = dev,name = Sue Jones,pay = 133100]
Tom Jones => [Manager:job = mgr,name = Tom Jones,pay = 50000]

未來(lái)方向

通過(guò)這個(gè)例子，我們可以看到了Python的OOP的所有基本機(jī)制的實(shí)際運(yùn)作，并且，學(xué)習(xí)了在代碼中避免冗余性及其相關(guān)可維護(hù)性問(wèn)題的方法，還構(gòu)建了功能完備的類(lèi)來(lái)完成實(shí)際的工作。此外，我們還通過(guò)把對(duì)象存儲(chǔ)到Python的shelve中創(chuàng)建了正式的數(shù)據(jù)庫(kù)記錄，從而使它們的信息持久地存在。

這之后還有更多的內(nèi)容可以探討，比如擴(kuò)展使用工具的范圍，包括Python附帶的工具以及開(kāi)源世界中可以免費(fèi)獲取的工具：

GUI：添加圖形化的用戶(hù)界面來(lái)瀏覽和更新數(shù)據(jù)庫(kù)記錄?？梢詷?gòu)建能夠移植到Python的tkinter的GUI，或者可以移植到WxPython和PyQt這樣的第三方工具的GUI。tkinter是Python自帶的，允許我們快速地構(gòu)建簡(jiǎn)單的GUI，并且是學(xué)習(xí)GUI編程技巧的理想工具。

Web站點(diǎn)：盡管GUI方便而且很快，但Web在易用性方面勝出。Web站點(diǎn)可以用Python自帶的基本CGI腳本編程工具來(lái)構(gòu)建，也可以用像Django、TurboGears、Pylons、web2Py、Zope或Google's App Engine這樣的全功能的第三方Web開(kāi)發(fā)框架來(lái)完成。

數(shù)據(jù)庫(kù)：如果數(shù)據(jù)庫(kù)變得更大或者更關(guān)鍵，我們可以將其從shelve轉(zhuǎn)移到像開(kāi)源的ZODB面向?qū)ο髷?shù)據(jù)庫(kù)系統(tǒng)（OODB）這樣一個(gè)功能更完備的存儲(chǔ)機(jī)制中，或者像MySQL、Oracle、PostgreSQL或SQLLite這樣的一個(gè)更傳統(tǒng)的基于SQL的數(shù)據(jù)庫(kù)系統(tǒng)中。Python自身帶有一個(gè)內(nèi)置的、正在使用的SQLLite數(shù)據(jù)庫(kù)。

ORM：如果我們真的遷移到關(guān)系數(shù)據(jù)庫(kù)中進(jìn)行存儲(chǔ)，不一定要犧牲Python的OOP工具。可以用SQLObject和SQLAlchemy這樣的對(duì)象關(guān)系映射器（ORM）。

更多關(guān)于Python相關(guān)內(nèi)容感興趣的讀者可查看本站專(zhuān)題：《Python面向?qū)ο蟪绦蛟O(shè)計(jì)入門(mén)與進(jìn)階教程》、《Python數(shù)據(jù)結(jié)構(gòu)與算法教程》、《Python函數(shù)使用技巧總結(jié)》、《Python字符串操作技巧匯總》、《Python編碼操作技巧總結(jié)》及《Python入門(mén)與進(jìn)階經(jīng)典教程》

希望本文所述對(duì)大家Python程序設(shè)計(jì)有所幫助。