Python面向对象程序设计OOP深入分析【构造函数,组合类,工具类等】
本文深入分析了Python面向对象程序设计OOP。分享给大家供大家参考，具体如下：
下面是一个关于OOP的实例，模块文件为person.py
#Fileperson.py(start)
classPerson:
def__init__(self,name,job=None,pay=0):
self.name=name
self.job=job
self.pay=pay
deflast_name(self):
returnself.name.split()[-1]
defgive_raise(self,percent):
self.pay=int(self.pay*(1+percent))
print('totalpercent:%f'%percent)
def__str__(self):
return'[Person:%s,%s]'%(self.name,self.pay)
classManager(Person):
#这是一种不太好的方法重载的方法，实际应用中我们采用下面的方法
defgive_raise(self,percent,bonus=.1):
self.pay=int(self.pay*(1+percent+bonus))
#这个方法利用了这样的一个事实：类方法总是可以在一个实例中调用。
#其实常规的实例调用，也是转换为类的调用
#instance.method(args...)由Python自动地转换为class.method(instance,args...)
#所以要记得直接通过类进行调用时，必须手动传递实例，这里就是self参数
#而且不能写成self.give_raise，这样会导致循环调用
#
#那么为什么采用这种形式呢？因为它对未来的代码的维护意义重大，因为give_raise现在
#只在一个地方，即Person的方法，将来需要修改的时候，我们只需要修改一个版本
defgive_raise(self,percent,bonus=.1):
Person.give_raise(self,percent+bonus)
if__name__=='__main__':
#self-testcode
bob=Person('BobSmith')
sue=Person('SueJones',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('TomJones','mgr',50000)
tom.give_raise(.1)
print(tom.last_name())
print(tom)
print('--Allthree--')
forobjin(bob,sue,tom):
obj.give_raise(.1)
print(obj)
这个示例定义了Person类，并且Person类的构造函数采用了默认关键字参数，重载了__str__方法用以print输出，定义了得到last_name的方法，定义了give_raise涨工资方法。类Manager继承自Person，Manager重新定义了自己的give_raise方法，获得额外的bonus=0.1的奖金。
在代码最后，写了自测试的代码if__name__=='__main__',用以测试。输出如下：
[Person:BobSmith,0]
[Person:SueJones,100000]
SmithJones
totalpercent:0.100000
[Person:SueJones,110000]
--------------------
totalpercent:0.200000
Jones
[Person:TomJones,60000]
--Allthree--
totalpercent:0.100000
[Person:BobSmith,0]
totalpercent:0.100000
[Person:SueJones,121000]
totalpercent:0.200000
[Person:TomJones,72000]
这里也可以给Manager增加自己独有的方法。
定制构造函数
现在的代码可以正常工作，但是，如果仔细研究会发现，当我们创建Manager对象的时候，必须为它提供一个mgr工作名称似乎没有意义：这已经由类自身暗示了。
所以，为了改善这点，我们要重新定义Manager中的__init__方法，从而提供mgr字符串，而且和give_raise的定制一样，通过类名的调用来运行Person中最初的__init__。
def__init__(self,name,pay): Person.__init__(self,name,'mgr',pay)
那么之后的实例化就变成了：
tom=Manager('TomJones',50000)
OOP比我们认为的简单
这是Python的OOP机制中几乎所有重要的概念：
- 实例创建——填充实例属性
- 行为方法——在类方法中封装逻辑
- 运算符重载——为打印这样的内置操作提供行为
- 定制行为——重新定义子类中的方法以使其特殊化
- 定制构造函数——为超类步骤添加初始化逻辑。
组合类的其他方式
有时候，我们可以以其他的方式组合类。例如，一种常用的编码模式是把对象彼此嵌套以组成复合对象，而不是继承。如下的替代方法使用__getattr__运算符重载方法来拦截未定义属性的访问。这时候，我们的代码如下：
classPerson: ...same... classManager(): def__init__(self,name,pay): self.person=Person(name,'mgr',pay) defgive_raise(self,percent,bonus=.1): self.person.give_raise(percent+bonus) def__getattr__(self,attr): returngetattr(self.person,attr) def__str__(self): returnstr(self.person) if__name__=='__main__': ...same...
实际上，这个Manager替代方案是一种叫做委托的常用代码模式的一个代表，委托是一种基于符合的结构，它管理一个包装的对象并且把方法调用传递给它。
这里Manager不是一个真正的Person，因此，我们必须增加额外的代码为嵌入的对象分派方法，比如像__str__这样的运算符重载方法必须重新定义。所以它需要的代码量增加，对于这个例子来说，没有哪个明智的Python程序员会按照这种方式组织代码，但是，当嵌入的对象比直接定制隐藏需要与容器之间有更多有限的交互时，对象嵌入以及基于其上的设计模式还是很适合的。
下述代码假设Department可能聚合其他对象，以便将它们当做一个集合对待。
classDepartment: def__init__(self,*args): self.members=list(args) defadd_member(self,person): self.members.append(person) defgive_raise(self,percent): forpersoninself.members: person.give_raise(percent) defshow_all(self): forpersoninself.members: print(person) development=Department(bob,sue) development.add_member(tom) development.give_raise(.1) development.show_all()
这里的代码使用了继承和复合——Department是嵌入并控制其他对象的聚合的一个复合体，但是，嵌入的Person和Manager对象自身使用继承来定制。作为另一个例子，一个GUI可能类似地使用继承来定制标签和按钮的行为或外观，但也会复合以构建嵌入的挂件（如输入表单、计算器和文本编辑器）的一个更大的包。
使用内省类工具
我们定制构造函数之后的Manager类还有几点小问题如下：
- 打印的时候，Manager会把他标记为Person。如果能够用最确切（也就是说最低层）的类来显示对象，这可能会更准确些。
- 其次，当前的显示格式只是显示了包含在__str__中的属性，而没有考虑未来的目标。例如，我们无法通过Manager的构造函数验证tom工作名已经正确地设置为mgr，因为我们为Person编写的__str__没有打印出这一字段。更糟糕的是，如果我们改变了在__init__中分配给对象的属性集合，那么还必须记得也要更新__str__以显示新的名字，否则，将无法随着时间的推移而同步。
我们可以使用Python的内省工具来解决这两个问题，它们是特殊的属性和函数，允许我们访问对象实现的一些内部机制。例如，在我们的代码中，有两个钩子可以帮助我们解决问题：
- 内置的instance.__class__属性提供了一个从实例到创建它的类的链接。类反过来有一个__name__，还有一个__bases__序列，提供了超类的访问。我们使用这些来打印创建的一个实例的类的名字，而不是通过硬编码来做到。
- 内置的object.__dict__属性提供了一个字典，带有一个键/值对，以便每个属性都附加到一个命名空间对象（包括模块、类和实例）。由于它是字典，因此我们可以获取键的列表、按照键来索引、迭代其值等等。我们使用这些来打印出任何实例的每个属性，而不是在定制显示中硬编码。
下面是这些工具在交互模式下的实际使用情形：
>>>frompersonimportPerson
>>>bob=Person('BobSmith')
>>>print(bob)
[Person:BobSmith,0]
>>>bob.__class__
>>>bob.__class__.__name__
'Person'
>>>list(bob.__dict__.keys())
['name','pay','job']
>>>forkeyinbob.__dict__:
...print(key,'=>',bob.__dict__[key])
...
name=>BobSmith
pay=>0
job=>None
>>>forkeyinbob.__dict__:
...print(key,'=>',getattr(bob,key))
...
name=>BobSmith
pay=>0
job=>None
一种通用的显示工具
新打开一个文件，并编写如下代码：它是一个新的、独立的模块，名为classtools.py，仅仅实现了这样一个类。由于其__str__，print重载用于通用的内省工具，它将会对任何实例有效，不管实例的属性集合是什么。并且由于这是一个类，所以它自动变成一个公用的工具：得益于继承，他可以混合到想要使用它显示格式的任何类中。作为额外的好处，如果我们想要改变实例的显示，只需要修改这个类即可。
#Fileclasstools.py
"""Assortedclassutilitiesandtools"""
classAttrDisplay:
"""
Providesaninheritableprintoverloadmethodthatdisplays
instanceswiththeirclassnamesandaname-valuepairfor
eachattributestoredontheinstanceitself(butnotattrs
inheritedfromitsclasses).Canbemixedintoanyclass,
andwillworkonanyinstance.
"""
defgatherAttrs(self):
attrs=[]
forkeyinsorted(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__':
classTopTest(AttrDisplay):
count=0
def__init__(self):
self.attr1=TopTest.count
self.attr2=TopTest.count+1
TopTest.count+=2
classSubTest(TopTest):
pass
x,y=TopTest(),SubTest()
print(x)
print(y)
注意这里的文档字符串，作为通用的工具，我们需要添加一些功能来产生文档。
这里定义的__str__显示了实例的类，及其所有的属性名和值，按照属性名排序。
[TopTest:attr1=0,attr2=1]
[SubTest:attr1=2,attr2=3]
工具类的命名考虑
最后一点需要考虑的是，由于classtools模块中的AttrDisplayz类旨在和其他任意类混合的通用性工具，所以我们必须注意与客户类潜在的无意的命名冲突。如果一个子类无意地自己定义了一个gatherAttrs名称，它很可能会破坏我们的类。
为了减少这样的名称冲突的机会，Python程序员常常对于不想做其他用途的方法添加一个【单个下划线】的前缀，在我们这个例子中就是_gatherAttrs。这不是很可靠，如果一个子类也定义了_gatherAttrs，该如何是好？但是它通常已经够用了，并且对于类内部的方法，这是常用的Python命名惯例。
一种更好但是不太常用的方法是，只在方法名前面使用【两个下划线】符号，__gatherAttrs,Python自动扩展这样的名称，以包含类的名称，从而使它们变得真正唯一。这一功能通常叫做【伪私有类属性】，将在以后介绍。
首先要使用打印这一通用工具，所需要做的是从其模块中导入它，使用继承将其混合到顶层类中，并且删除我们之前编写的更专门的__str__方法。新的打印重载方法将会由Person的实例继承，Manager的实例也会继承。
下面就是类的最终形式：
#Fileperson.py(start)
fromclasstoolsimportAttrDisplay
classPerson(AttrDisplay):
"""
Createandprocesspersonrecords
"""
def__init__(self,name,job=None,pay=0):
self.name=name
self.job=job
self.pay=pay
deflast_name(self):
returnself.name.split()[-1]
defgive_raise(self,percent):
self.pay=int(self.pay*(1+percent))
print('totalpercent:%f'%percent)
classManager(Person):
"""
AcustomizedPersonwithspecialrequirements
"""
def__init__(self,name,pay):
Person.__init__(self,name,'mgr',pay)
defgive_raise(self,percent,bonus=.1):
Person.give_raise(self,percent+bonus)
if__name__=='__main__':
#self-testcode
bob=Person('BobSmith')
sue=Person('SueJones',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('TomJones',50000)
tom.give_raise(.1)
print(tom.last_name())
print(tom)
在这个版本中，也添加了一些新的注释来记录所做的工作和每个最佳实践惯例——使用了功能性描述的文档字符串和用于简短注释的#。现在运行这段代码，将会看到对象的所有属性，并且最终的问题也解决了：由于AttrDisplay直接从self实例中提取了类名，所有每个对象都显示其最近的（最低的）类的名称——tom现在显示为Manager，而不是Person。
[Person:job=None,name=BobSmith,pay=0]
[Person:job=dev,name=SueJones,pay=100000]
SmithJones
totalpercent:0.100000
[Person:job=dev,name=SueJones,pay=110000]
--------------------
totalpercent:0.200000
Jones
[Manager:job=mgr,name=TomJones,pay=60000]
这正是我们所追求的更有用的显示，我们属性显示类已经变成了一个【通用工具】，可以通过继承将其混合到任何类中，从而利用它所定义的显示格式。
最后：把对象存储到数据库中
我们创建的对象还不是真正的数据库记录，他们只是内存中的临时对象，而没有存储到文件这样更为持久的媒介中。所以，现在要使用Python的一项叫做【对象持久化】的功能把对象保存。
Pickle和Shelve
对象持久化通过3个标准的库模块来实现，这3个模块在Python中都可用：
- pickle:任意的Python对象和字节串之间的序列化
- dbm:实现一个可通过键访问的文件系统，以存储字符串
- shelve：使用另两个模块按照把Python对象存储在一个文件中。
在Shelve数据库中存储对象
让我们编写一个新的脚本，把类的对象存储到shelve中。在文本编辑器中，打开一个名为makedb.py的新文件，导入shelve模块，用一个外部文件名打开一个新的shelve，把对象赋给shelve中的键，当我们操作完毕之后关闭这个shelve，因为已经做了修改：
#Filemakedb.py:storePersonobjectsonashelvedatabase
frompersonimportPerson,Manager
importshelve
bob=Person('BobSmith')
sue=Person('SueJones',job='dev',pay='100000')
tom=Manager('TomJones',50000)
db=shelve.open('persondb')
forobjin(bob,sue,tom):
db[obj.name]=obj
db.close()
注意，这里我们把对象的名字用作键，从而把他们赋给shelve，这么做只是为了方便，在shelve中，键可以是任何的字符串，唯一的规则是，键必须是字符串并且是唯一的。这样，我们就可以针对每个键只存储一个对象。然而，我们在键之下的值可以是几乎任何类型的Python对象：像字符串、列表和字典这样的内置对象，用户定义的类实例，以及所有这些嵌套式的组合。
运行这段代码，没有输出，意味着他可能有效。
交互式探索shelve
此时，当前的目录下会有一个或多个真实的文件，它们的名字都以‘persondb'开头。这就是我们存储的文件，也就是我们的数据库，是我们备份或移动存储的时候需要复制和转移的内容。
在交互式命令窗口中可以查看这些文件：
>>>importglob
>>>glob.glob('person*')
['person.py','person2.py','persondb.bak','persondb.dat','persondb.dir']
>>>print(open('persondb.dir').read())
'TomJones',(1024,91)
'SueJones',(512,100)
'BobSmith',(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
...moreomitted...
这些内容无法解读，但是我们可以用常规的Python语法和开发模式来处理它，即通过shelve来打开这些文件。
>>>importshelve
>>>db=shelve.open('persondb')
>>>forkeyindb:
...print(key,'=>',db[key])
...
BobSmith=>[Person:job=None,name=BobSmith,pay=0]
TomJones=>[Manager:job=mgr,name=TomJones,pay=50000]
SueJones=>[Person:job=dev,name=SueJones,pay=100000]
>>>len(db)
3
>>>bob=db['BobSmith']
>>>bob.last_name()
'Smith'
在这里，为了载入或使用存储的对象，我们不一定必须导入Person或Manager类。因为Python对一个类实例进行pickle操作，它记录了其self实例属性，以及实例所创建于的类的名字和类的位置。
这种方法的结果就是，类实例在未来导入的时候，会自动地获取其所有的类行为。
更新Shelve中的对象
现在介绍最后一段脚本，编写一个程序，在每次运行的时候更新一个实例，以此证实我们的对象真的是持久化的。如下的updatadb.py打印出数据库，并且每次把我们所存储的对象之一增加一次，跟踪它的变化：
BobSmith=>[Person:job=None,name=BobSmith,pay=0]
SueJones=>[Person:job=dev,name=SueJones,pay=110000]
TomJones=>[Manager:job=mgr,name=TomJones,pay=50000]
TomJones=>[Manager:job=mgr,name=TomJones,pay=50000]
SueJones=>[Person:job=dev,name=SueJones,pay=121000]
BobSmith=>[Person:job=None,name=BobSmith,pay=0]
BobSmith=>[Person:job=None,name=BobSmith,pay=0]
SueJones=>[Person:job=dev,name=SueJones,pay=133100]
TomJones=>[Manager:job=mgr,name=TomJones,pay=50000]
未来方向
通过这个例子，我们可以看到了Python的OOP的所有基本机制的实际运作，并且，学习了在代码中避免冗余性及其相关可维护性问题的方法，还构建了功能完备的类来完成实际的工作。此外，我们还通过把对象存储到Python的shelve中创建了正式的数据库记录，从而使它们的信息持久地存在。
这之后还有更多的内容可以探讨，比如扩展使用工具的范围，包括Python附带的工具以及开源世界中可以免费获取的工具：
GUI：添加图形化的用户界面来浏览和更新数据库记录。可以构建能够移植到Python的tkinter的GUI，或者可以移植到WxPython和PyQt这样的第三方工具的GUI。tkinter是Python自带的，允许我们快速地构建简单的GUI，并且是学习GUI编程技巧的理想工具。
Web站点：尽管GUI方便而且很快，但Web在易用性方面胜出。Web站点可以用Python自带的基本CGI脚本编程工具来构建，也可以用像Django、TurboGears、Pylons、web2Py、Zope或Google'sAppEngine这样的全功能的第三方Web开发框架来完成。
数据库：如果数据库变得更大或者更关键，我们可以将其从shelve转移到像开源的ZODB面向对象数据库系统（OODB）这样一个功能更完备的存储机制中，或者像MySQL、Oracle、PostgreSQL或SQLLite这样的一个更传统的基于SQL的数据库系统中。Python自身带有一个内置的、正在使用的SQLLite数据库。
ORM：如果我们真的迁移到关系数据库中进行存储，不一定要牺牲Python的OOP工具。可以用SQLObject和SQLAlchemy这样的对象关系映射器（ORM）。
更多关于Python相关内容感兴趣的读者可查看本站专题：《Python面向对象程序设计入门与进阶教程》、《Python数据结构与算法教程》、《Python函数使用技巧总结》、《Python字符串操作技巧汇总》、《Python编码操作技巧总结》及《Python入门与进阶经典教程》
希望本文所述对大家Python程序设计有所帮助。