Python学习笔记整理(十六)类的设计

如何使用类来对有用的对象进行建模？
一、Python和OOP
Python和OOP实现可以概括为三个概念。
继承
    继承是基于Python中属性查找（在X.name表达式中）
多态
    在X.method方法中，method的意义取决于X的类型（类）
封装
    方法和运算符实现行为，数据隐藏默认是一种惯例。
封装指的是在Python中打包，也就是把实现的细节隐藏在对象接口之后。这并不代表有强制的私有性。封装可以让对象接口的现实
出现变动时，不影响这个对象的用户。
1、不要通过调用标记进行重载
不要在同一个类中对同一个方法名定义两次，后面的会覆盖前面，也不要对对象类型进行测试。应该把程序代码写成预期的对象接口。而不是特定类型的数据类型。
2、类作为记录
通过类的实例来创建多个记录。
3、类和继承：是“一个”关系 （is a)
从程序员的角度来看，继承是由属性点号运算启动的，由此触发实例，类以及任何超类中变量名搜索。
从设计师的角度看，继承是一种定义集合成员关系的方式：类定义了一组内容属性，可由更具体的集合（子类）继承和定制。
子类和超类的继承是1对1的关系.
PizzaRobot是一种Chef,Chef是一种Employee.以OOP术语来看，我们称这些关系为“是一个连接”(is a)：机器人是个主厨，主厨是一个员工。
class Employee:
        def __init__(self,name,salary=0):
                self.name=name
                self.salary=salary
        def giveRaise(self,percent):
                self.salary=self.salary+(self.salary*percent)
        def work(self):
                print self.name,"does stuff"
        def __repr__(self):
                return "" % (self.name,self.salary)
class Chef(Employee):
        def __init__(self,name):
                Employee.__init__(self,name,5000)
        def work(self):
                print self.name,"make food"
class Server(Employee):
        def __init__(self,name):
                Employee.__init__(self,name,40000)
        def work(self):
                print self.name,"interface with customer"
class PizzaRobot(Chef):   
        def __init__(self,name):#有点想不明白，既然继承就够了，为什么还要在这里构造
                Chef.__init__(self,name)    #Chef.__init__(self,name) =》Employee.__init__(self,name,5000)=>__init__(self,name,salary=0)
        def work(self):
                print self.name,"make pizza"
if __name__=='__main__':
        bob=PizzaRobot('bob')
        print bob
        bob.work()
        bob.giveRaise(0.20)
        print bob;print
# python employees.py  

bob make pizza

理解有问题的地方
class PizzaRobot(Chef):   
        def __init__(self,name):#有点想不明白，既然继承就够了，为什么还要在这里构造，下面拿掉这里做对比
                Chef.__init__(self,name)   
#Chef.__init__(self,name) =》Employee.__init__(self,name,5000)=>__init__(self,name,salary=0) 连接过程
        def work(self):
                print self.name,"make pizza"
下面拿掉PizzaRobot类中的def __init__(self,name):
# python employees.py

bob make pizza
结果一样，那这个函数还有什么必要做构造，直接继承就可以了
导入进行其他测试
>>> import employees
>>> obj=employees.Employee(employees.Employee.__name__)
>>> obj.work
Employee does stuff
if下面增加如下代码：
        for klass in Employee,Chef,Server,PizzaRobot:
                obj=klass(klass.__name__)
                obj.work()
代码对应的结果
#python employees.py
Employee does stuff
Chef make food
Server interface with customer
PizzaRobot make pizza
4、类和组合：”有一个“关系 （has a)
从程序员的角度来看，组合设计到把其他对象嵌入到容器对象内，并使其实现容器方法。
对设计师来说，组合是另一种表示问题领域中的关系的方法。
但是组合不是集合的成员关系，而是组件，也是整体的组成部分。
组合也反映了个组成部分之间的关系，通常称为“有一个”(has a)关系。Python中，“组合”（聚合）就是指内嵌对象集合体。
组合类一般都提供自己的接口，并通过内嵌的对象来实现接口。
现在，我们有了员工，把他们放到披萨店。我们的披萨店是一个组合对象，有烤炉，也有服务员和主厨这些员工。当顾客来下单
时，店里的组件就开始行动：服务员接下订单，主厨制作披萨等。。pizzashop.py模拟
from employees import PizzaRobot,Server

class Customer:
        def __init__(self,name):
                self.name=name
        def order(self,server):
                print self.name,"oders from",server
        def pay(self,server):
                print self.name,"pays for item to",server

class Oven:
        def bake(self):
                print "oven bakes"

class PizzaShop:
        def __init__(self):
                self.server=Server('Pat')
                self.chef=PizzaRobot('Bob')
                self.oven=Oven()
        def order(self,name):
                customer=Customer(name)
                customer.order(self.server)
                self.chef.work()
                self.oven.bake()
                customer.pay(self.server)

if __name__=="__main__":
        scene=PizzaShop()
        scene.order('lily')
        print '...'
        scene.order('kelly')
# python pizzashop.py
lily oders from
Bob make pizza
oven bakes
lily pays for item to
...
kelly oders from
Bob make pizza
oven bakes
kelly pays for item to
PizzaShop类是容器和控制器，其构造器会创建employees模块中员工类的实例，并将其嵌入。当模块的自我检查程序代码
调用PizzaShop的order方法时，内嵌的对象会按顺序进行工作。注意：每份订单创建了Customer对象，而且把内嵌的Server
对象传递给Customer方法，顾客是流动的，但是服务员是披萨店的组成部分。另外，员工也涉及到了继承关系，组合和继承
是互补工具。
if检测改写一下，通过参数传递客户给模块
if __name__=="__main__":
        try:
                customer=getargv[1]
        except:
                print "please give argv as customer!"
        else:
                scene=PizzaShop()
                scene.order(customer)
                print '...'
# python pizzashop.py tom
tom oders from
Bob make pizza
oven bakes
tom pays for item to
...
5、重访流处理器
# vim streams.py
class Processor:
        def __init__(self,reader,writer):
                self.reader=reader
                self.writer=writer
        def process(self)：
                while 1:
                        data=self.reader.readline()
                        if not data:break #这里有错误是not
                        data=self.converter(data)
                        self.writer.write(data)  #这里有错误write
        def converter(self,data)
                assert 0,'converter must be defined
# vim converter.py           
from streams import Processor
from sys import stdout as output
class Uppercase(Processor):
                def converter(self,data):
                        return data.upper()

if __name__=="__main__":
        Uppercase(openfile('/etc/rc.conf'),output).process()
错误from sys import open as openfile
ofreebsd# python converter.py
Traceback (most recent call last):
  File "converter.py", line 2, in
    from sys import open as openfile
open是内置函数无需导入、
6、类和持续性
持续性：保证数据的持续性，将数据保存在文件或者数据库，继续保存。
pickle和shelve模块和类实例结合起来使用效果很好，通过单个步骤存储到硬盘上。
>>> from pizzashop import PizzaShop
>>> import pickle
>>> obj=PizzaShop()
>>> obj.server

file=open('pizzashop_data','w')
>>> pickle.dump(obj.server,file) #写入
>>> file.close()
# cat pizzashop_data
(iemployees
Server
p0
(dp1
S'salary'
p2
I40000
sS'name'
p3
S'Pat'
p4
读取
>> objread=pickle.load(file)      
>>> print objread
ile=open('pizzashop_data','r')
pickle机制把内存中的对象转换成序列化的字节流，可以保存在文件中。
Shelve会自动把对象pickle生成按键读取的数据库，而此数据库导出类似于字典的接口.
>>> from pizzashop import PizzaShop
>>> obj=PizzaShop()
>>> obj.server

>>> import shelve
>>> dbase=shelve.open('datafile')
>>> dbase['key']=obj.server 写入
>>> dbase.sync
}>
# cat datafile.db
>>> dbase['name']='diege' #写入
>>> dbase.sync         
}>
>>> dbase.close()
# cat datafile.db
a?
      



(
?n}　
¤?¤S'diege'
p1
.name(iemployees
Server
p1
(dp2
S'salary'
p3
I40000
sS'name'
p4
S'Pat'
p5
读取
>>> import shelve
>>> shtest=shelve.open('datafile')
>>> shtest['key']

>>> shtest['name']      
'diege'

二、OOP和委托
所谓的委托，通常就是指控制器对象内嵌其他对象，而把运算请求传给那些对象。控制器负责管理工作。
在Python中，委托通常是以__getattr__钩子方法实现的，因为这个方法会拦截对不存在属性的读取，包装类（代理类）可以使用__getattr__把任意读取转发给包装的对象。包装类包有被包括对象的接口。而且自己也可以增加其他运算。
class wrapper:
    def __init__(self,object):
        self.wrapped=object
    def __getattr__(self,attrname):        #__getattr__点号运算，这里重载内置getattr方法打印传入类执行的方法，并把属性请求传入给对象，使用对象默认的方法。委托
        print 'Trace:',attrname
        return getattr(self.wrapped,attrname)
__getattr__会获得属性名称字符串。这个程序代码利用getattr内置函数，以变量名字符串从包裹对象取出属性：getattr(X,Z)
就像X.N，只不过N是表达式，可以在运行时计算出字符串，而不是变量。getattr(X,Z)类似于X.__dict__[N].
可以使用这个模块包装类的做法，管理人和带有属性的对象的存取：列表，字典甚至是类和实例。
在这里wrapper类只是在每个属性读取时打印跟踪信息，【并把属性请求委托给嵌入的wrapped对象。（对象自己的方法）】

>>> from trac import wrapper
>>> x=wrapper([1,2,3])
>>> x.append
Trace: append

>>> x.append(4)
Trace: append
>>> for n in x:print n
...
Trace: __iter__
1
2
3
4
>>> x.wrapped
[1, 2, 3, 4]
>>> x.__dict__
{'wrapped': [1, 2, 3, 4]}
>>> x=wrapper({"a":1,"b":2})
>>> x.keys()
Trace: keys
['a', 'b']
>>> x.__dict__
{'wrapped': {'a': 1, 'b': 2}}
>>> x        
Trace: __repr__
{'a': 1, 'b': 2}

三、多重继承
在class语句中，首行括号内可以列出一个以上的超类。当这么做时，就在使用所谓的多重继承：类和其实例继承了列出的所有超类的变量。搜索属性时，Python会由左到右搜索类首行中的超类，直到找到相符者。
通常意义上讲，多重继承是模拟属于一个集合以上的对象的好办法，例如一个人可以是工程师，作家，音乐家。因为，可以继承这些集合的特性。
多重继承最常见的用户是作为“混合”超类的通用方法。这类超类一般都称呼混合类：他们提供方法，可以通过继承将其加入应用类。
>>> x.__class__

>>> x.__class__.__name__
'wrapper'
每个实例都有内置的__class__属性，引用了它所继承的类，而每个类都有__name__属性，用用了首行中的变量名，所以self.__class__.__name__是取出实例的类的名称
>>> x.__class__.__module__      
'trac'
>>> x.__module__         
'trac
而是用self.__module__或 self.__class__.__module__则取出实例引用模块的名称
内置id函数传回任意对象的地址（从定义上来将。这就是唯一的对象识别码），从而获得实例的内存地址。
# vim mytool.py
class Lister:
        def __repr__(self): #打印重载
                return ("                                 (self.__class__.__name__,
                                 id(self),
                                 self.attrnames()) ) #抽象类
        def attrnames(self):
                result=''
                for attr in self.__dict__.keys():
                        if attr[:2]=='__':
                                result=result+"\tname %s=\n" % attr
                        else:
                                result=result+"\tname %s=%s\n" % (attr,self.__dict__[attr])
                return result
从这个类衍生的实例会在打印时自动显示器属性。
>>> from mytool import Lister
>>> dir(Lister)
['__doc__', '__module__', '__repr__', 'attrname']
>>> class Diege(Lister):
...     def __init__(self):
...             self.data1='food'
...
>>> y=Diege()
>>> y
        name data1=food
>
将__repr_修改为__str__
>>> y=Diege()
>>> y
>>> print y
        name data1=food
>
Lister类对所写的任何类都有用：即时是已经有超类的类，这里就是多重继承方便之处：把Lister加到类首行的超类列表中（将其混合进来）
就可以获得其__repe，同时依然继承现有的超类。
# vim Tsmixin.py
from mytool import Lister

class Super:
        def __init__(self):
                self.data1='diege'
               
class Sub(Super,Lister):
        def __init__(self):
                Super.__init__(self)
                self.data2="eggs"
                self.data3=42
if __name__=='__main__':
        X=Sub()
        print X
# python Tsmixin.py  
        name data1=diege
        name data3=42
        name data2=eggs
>
如果稍后你决定扩展Lister的__repr__，也要打印实例继承的所有类属性，那也很安全。因为这是继承的方法，修改Lister.__repr__会自动更新每个导入类，
并将显示器混合进来的子类的情况。
总之，混合类相当于模块：可用户在各种客户端的方法包。以下是Lister用在不同类实例上，采用单个继承模式的情况。
>>> class X(Lister):
...     pass
... 
>>> t=x()
>>> t
>
>>> t
        name a=1
        name c=3
        name b=2
>
OOP其实就是代码重用，而混合是强大的工具。多重继承是高级功能，如果用的过度或太随意，就变得很复杂。

四、类是对象：通用对象的工厂
类是对象，因此它很容易在程序中进行传递，保存在数据库结构中。也可以把类传给产生任意种类对象的函数。这类函数在OOP设计领域偶尔称为工厂。
工厂式的函数或程序代码，在一些情况下很方便，因为他们可以让我们取出并传入没有预先在程序代码中硬编码的类。实际上，这些类在编写程序时可能还不存在。抽象类。
>>> def factory(aClass,*args):
...     return apply(aClass,args)
...
>>> class Spam:
...     def doit(self,message):
...             print message
...
>>> class Person:                  
...     def __init__(self,name,job):
...             self.name=name
...             self.job=job
>>> object1=factory(Spam)
>>> object2=factory(Person,"diege","lily")
这里定义了一个对象生成器函数，称为factory.它预期传入的是类对象（任何对象都行），还有该类构造器的一个或多个参数。这个函数使用apply调用该函数并返回实例。
可以改进之处就是，在构造器调用中支持关键词参数。函数factory能够通过**agrs参数手机参数。当第三个参数传给apply时：
def factory(aClass,*args,**kagrs):
...     return apply(aClass,kargs)
在Python中一切都是对象。

五、方法是对象：绑定或无绑定
方法也是一种对象，很像函数。类方法能有实例或类来读取。实际上Python中就有两种方式。
无绑定类方法对象：无self
    通过对类进行点号运算从而获取类的函数属性，会传回无绑定(unboud)方法对象。调用该方法时，【必须明确提供实例对象】作为第一个参数。
绑定实例方法对象：self+函数对
    通过对实例进行全运算从而获取类的函数属性，会传回绑定（bound)方法对象。Python在绑定方法对象中自动把实例和函数打包，所以，不用传递实例去调用该方法。实例已拥有该方法。
这两种方法都是功能齐全的对象，可四处传递，保持在列表内等。执行时两者都需要第一参数的实例（也就是self的值）.
调用绑定方法对象时，Python会自动提供实例来创建绑定方法对象的实例。也就是说绑定方法对象通常都可以和简单函数对象互换，而且对原本就是针对函数而编写的接口而言，非常用有。
>>> class Spam:
...     def doit(self,message):
...             print message
>>> object1=Spam()
>>> object1.doit('hellow world')           
hellow world
可以帮这个绑定方法赋值给另一个变量名，然后像简单函数那样进行调用。
>>> object1=Spam()
>>> x=object1.doit
>>> x('hello world')
hello world

六、类和模块
都是命名空间
模块
        * 是数据/逻辑套件
        * 由Python文件或C扩展编写成
        * 通过导入使用
类
        *实现新的对象
        *由class语句创建
        *通过调用使用
        *总是存在于模块中。
类支持其他模块不支持的功能。例如，运算符重载，产生多个实例以及继承。

七、类陷阱
修改类属性的副作用
多重继承：顺序很重要
类，方法以及嵌套作用域

小结：
委托：把对象包装在代理类中
组合：控制嵌入的对象
继承：从其他类中获取行为
多重继承，绑定方法，工厂函数