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 "<Employee:name=%s,salary=%s>" % (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   <Employee:name=bob,salary=5000> bob make pizza <Employee:name=bob,salary=6000.0> 理解有问题的地方 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 <Employee:name=bob,salary=5000> bob make pizza <Employee:name=bob,salary=6000.0 结果一样，那这个函数还有什么必要做构造，直接继承就可以了 导入进行其他测试 >>> 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 <Employee:name=Pat,salary=40000> Bob make pizza oven bakes lily pays for item to <Employee:name=Pat,salary=40000> ... kelly oders from <Employee:name=Pat,salary=40000> Bob make pizza oven bakes kelly pays for item to <Employee:name=Pat,salary=40000> 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 <Employee:name=Pat,salary=40000> Bob make pizza oven bakes tom pays for item to <Employee:name=Pat,salary=40000> ... 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 <module>     from sys import open as openfile open是内置函数无需导入、 6、类和持续性 持续性：保证数据的持续性，将数据保存在文件或者数据库，继续保存。 pickle和shelve模块和类实例结合起来使用效果很好，通过单个步骤存储到硬盘上。 >>> from pizzashop import PizzaShop >>> import pickle >>> obj=PizzaShop() >>> obj.server <Employee:name=Pat,salary=40000> 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 <Employee:name=Pat,salary=40000>ile=open('pizzashop_data','r') pickle机制把内存中的对象转换成序列化的字节流，可以保存在文件中。 Shelve会自动把对象pickle生成按键读取的数据库，而此数据库导出类似于字典的接口. >>> from pizzashop import PizzaShop >>> obj=PizzaShop() >>> obj.server <Employee:name=Pat,salary=40000> >>> import shelve >>> dbase=shelve.open('datafile') >>> dbase['key']=obj.server 写入 >>> dbase.sync <bound method DbfilenameShelf.sync of {'key': <Employee:name=Pat,salary=40000>}> # cat datafile.db >>> dbase['name']='diege' #写入 >>> dbase.sync          <bound method DbfilenameShelf.sync of {'name': 'diege', 'key': <Employee:name=Pat,salary=40000>}> >>> 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'] <Employee:name=Pat,salary=40000> >>> 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 <built-in method append of list object at 0x2850f7ec> >>> 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__ <class trac.wrapper at 0x28503f8c> >>> 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 ("<Instance of %s,address %s:\n%s" %                                 (self.__class__.__name__,                                  id(self),                                  self.attrnames()) ) #抽象类         def attrnames(self):                 result=''                 for attr in self.__dict__.keys():                         if attr[:2]=='__':                                 result=result+"\tname %s=<built-in>\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 <Instance of Diege,address 676368300:         name data1=food > 将__repr_修改为__str__ >>> y=Diege() >>> y >>> print y <Instance of Diege,address 676368300:         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   <Instance of Sub,address 676367724:         name data1=diege         name data3=42         name data2=eggs > 如果稍后你决定扩展Lister的__repr__，也要打印实例继承的所有类属性，那也很安全。因为这是继承的方法，修改Lister.__repr__会自动更新每个导入类， 并将显示器混合进来的子类的情况。 总之，混合类相当于模块：可用户在各种客户端的方法包。以下是Lister用在不同类实例上，采用单个继承模式的情况。 >>> class X(Lister): ...     pass ...  >>> t=x() >>> t <Instance of X,address 676380940: > >>> t <Instance of X,address 676380940:         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语句创建         *通过调用使用         *总是存在于模块中。 类支持其他模块不支持的功能。例如，运算符重载，产生多个实例以及继承。 七、类陷阱 修改类属性的副作用 多重继承：顺序很重要 类，方法以及嵌套作用域 小结： 委托：把对象包装在代理类中 组合：控制嵌入的对象 继承：从其他类中获取行为 多重继承，绑定方法，工厂函数