Python学习笔记13:Python面向对象编程

1、引言
(1)类和实例:类是对象的定义,实例是“真正的实物”。
定义类:类名通常大写字母打头。

class MyNewObjectType(bases):
    'define MyNewObjectType class'
    class_suite

bases可以是一个(单继承)或多个(多重继承)用于继承的父类。
object是“所有类之母”。
Python调用类进行实例化,实例化类不使用new关键字。

>>>c=MyNewObjectType()

类有时可以仅作为名称空间。

class MyData(object):    
    pass
mathobj=MyData()
mathobj.x=4
mathobj.y=5

这些属性是动态的,不需要在构造器中或其他任何地方为它们预先声明或赋值。
(2)方法
定义方法:属性和方法使用驼峰记法。

class MyDataWithMethod(object):
    def printFoo(self):
        print ....

所有方法都存在self,表示实例对象本身。
静态方法或类方法不需要self。
__init__()方法类似于构造函数,但不同于构造函数,因Python不new。该方法在实例被创建后,实例化调用返回这个实例之前被调用。

2、面向对象编程常用术语

  • 抽象/实现:建模 现实化
  • 封装/接口
  • 合成:联合、聚合
  • 继承/派生
  • 泛化/特化
  • 多态
  • 自省/反射

3、类
Python中,一切皆为对象。
下面是类的定义语法。

class ClassName(object):
    'class documentation string'
    class_suite

Python不支持纯虚函数(像C++)或者抽象方法等。
替代方案:在基类方法中引发NotImplementedError异常。

4、类属性
(1)属性
属性(数据或函数),使用句点属性标识符来访问。
属性本身也是一个对象,也有自己的属性,所以访问属性时会形成一个属性链。
(2)类属性/实例数据属性
实例属性在OOP中用得最多,类属性仅当需要有更加“静态”数据类型时才变得有用,它和任何实例无关,方法是类属性。
Python要求,没有实例,方法不能被调用。方法必须“绑定”到一个实例才能直接被调用。非绑定的方法可能可以被调用,但实例对象一定要明确给出,才能保证调用成功。然而,不管是否绑定,方法都是它所在的类的固有属性,即使它们几乎总是通过实例来调用的。
(3)确定一个类有哪些属性的方法

  • 使用内建函数dir()
  • 访问类的字典属性__dict__
  • 内建函数vars()接受类对象作为参数,返回类的__dict__属性的内容。

(4)特殊的类属性

  • C.__name__ 类C的名字(字符串)
  • C.__doc__ 类C的文档字符串
  • C.__bases__ 类C的所有父类构成的元组
  • C.__dict__ 类C的属性
  • C.__module__ 类C所在的模块(1.5)
  • C.__class__ 实例C对应的类(新式类)

5、实例
Python 2.2中统一了类和类型。
Python通过调用类对象来创建实例。
①__init__()方法
当类被调用,创建实例对象,对象创建后,调用__init__()方法完成特别的操作,执行完返回类对象,实例化结束。
Python没有使用new创建实例,没有定义构造器,由Python创建对象。
②__new__()方法
“构造器”方法,与__init__()方法相比,__new__()更像一个真正的构造器,因为__new__()必须返回一个合法的实例,该实例作为self传给__init__()方法。
__new__()方法会调用父类的__new__()方法来创建对象。
在对内建类型进行派生时,__new__()方法可以实例化不可变对象。
③__del__()方法
“解构器”方法,当实例对象所有的引用都被清除掉后才执行该方法,用于实例释放前进行特殊处理。

  • __del__()方法只能被调用一次。
  • 使用__del__()方法,不要忘记首先调用父类的__del__()方法。
  • del x不表示调用x.__del__()方法,仅引用计数减少。
  • 若存在循环引用,则对象的__del__()方法可能永远不会被执行。
  • __del__()方法未捕获的异常会被忽略掉,除非有必要,否则不去实现__del__()方法。
  • 如果定义了__del__()方法,且实例是某个循环的一部分,垃圾回收器将不会终止这个循环,你需要自己显式调用del。

6、实例属性
方法严格来说是类属性。实例仅拥有数据属性。
(1)”实例化”实例属性
①在__init__()方法中设置实例属性。
设置实例的属性可以在实例创建后任意时间进行。__init__()方法是设置这些属性的关键点之一。Python能够在“运行时”创建实例属性(Python优秀特性之一)
②默认参数提供默认的实例安装。

class HotelRoomClac(object):
    def __init__(self,rt,sales=0.085,rm=0.1):
        self.salesTax=sales
        self.roomTax=rm
        self.roomRate=rt

③__init__()方法应该返回None
__init__()方法不应该返回任何对象,因为实例对象是自动在实例化调用后返回的。
(2)查看实例属性

  • 查看实例属性:dir()、__dict__属性、vars()
  • 特殊的实例属性:I.__class__、I.__dict__
  • 内建类型属性:内建类型可以使用dir()方法,不可以访问__dict__特殊属性,因为在内建类型中,不存在这个属性。

(3)类属性和实例属性(类似于自动变量和静态变量)
可以采用类来访问类属性,若实例没有同名的属性的话,也可以用实例来访问。
类属性可以通过类或实例来访问,不过只能使用类访问类属性时,才能更新类属性的值。若在实例中更新类属性,将会创建同名的实例属性,“遮蔽”了类属性。当删除同名的实例属性,类属性才起作用。所以,从实例中访问类属性须谨慎。

class C(object): #定义类
    version = 1.2#静态成员
>>>c=C()
>>>C.version #通过类来访问
>>>c.version #通过实例来访问
>>>C.version+=0.1 #通过类(只能这样)来更新类属性
>>>c.version =1.3 #任何对实例属性的赋值都会创建一个实例属性,而不是更新类属性

当类属性是可变类型时,并不会创建实例属性,直接操作的是类属性。

class Foo(object): 
    x={2003:'poe2'}
>>>foo=Foo()
>>>foo.x[2004]='valid path'
>>>foo.x
{2003:'poe2',2004:'valid path'}
>>>Foo.x
{2003:'poe2',2004:'valid path'} #生效了
>>>del foo.x #删除会报错,因为没有遮蔽所以不能删除掉

(4)类属性持久性
类属性,任凭整个实例(及其属性)的如何进展,他都不理不睬(因此独立于实例),类属性的修改会影响到所有的实例。类属性是静态成员。

7、绑定和方法调用
(1)绑定
方法仅仅是类内部定义的函数,意味着方法是类属性而不是实例属性。
方法只有在类拥有实例时,才能被调用。方法被认为是绑定到实例。方法中的变量self表示调用此方法的实例对象。
(2)方法调用
①调用非绑定的方法(不常见):类还未实例化。

class EmplAddrBookEntry(AddrBookEntry):
    'Employee Address Book Entry class'
    def __init__(self,nm,ph,em):
        AddrBookEntry.__init__(self,nm,ph) #覆盖父类方法
        self.empid=em

②调用绑定方法:类已经实例化。

>>>mc=MyClass()
>>>mc.foo()

总结:方法定义于类内部,是类方法;方法绑定到实例,由实例调用;未绑定,由类调用。

8、静态方法和类方法(2.2)
(1)经典类中创建静态方法和类方法的例子

class TestStaticMethod:
    def foo():
        print 'calling static method foo()'
        foo=staticmethod(foo)  #内建函数,将方法转换成静态方法
class TestClassMethod:
    def foo(cls):  #cls为类对象,类似于self
        print 'calling class method foo()'
        foo=classmethod(foo)   #内建函数,将方法转换成类方法

可以通过类或者实例调用这些函数。

>>>tsm=TestStaticMethod()
>>>TestStaticMethod.foo()
>>>tsm.foo()
>>>tcm=TestClassMethod()
>>>TestClassMethod.foo()
>>>tcm.foo()

(2)使用函数修饰符创建静态方法和类方法的例子(2.4)

class TestStaticMethod:
    @staticmethod
    def foo():
        print 'calling static method foo()'
class TestClassMethod:
    @classmethod
    def foo(cls):
        print 'calling class method foo()'

9、继承
(1)通过继承覆盖方法
子类定义与基类相同的方法时,会覆盖(override)基类方法。
子类可以使用调用非绑定的基类方法的方法调用基类方法。
也可以使用super()内建方法调用基类方法。
当从一个带构造器__init__()的类派生,如果你不去覆盖__init__(),它将会被继承并自动调用,但如果你在子类中覆盖了__init__(),子类被实例化时,基类的__init__()就不会被自动调用。若要调用父类的__init__()方法,需要使用super()。
(2)从标准类型派生
经典类中,不能对标准类型进行子类化。
2.2后,可以对标准类型进行子类化。
子类化Python类型:其中一个是可变类型;另一个是不可变类型。
①子类化不可变类型

class RoundFloat(float):
    def __new__(cls,val):
        return float.__new__(cls,round(val,2))

所有的__new__()方法都是类方法,所以显式地传入类作为第一个参数。

class RoundFloat(float):
    def __new__(cls,val):
        return super(RoundFloat,cls).__new__(cls,round(val,2))

通常使用super()内建函数去捕获对应的父类以调用它的__new__()方法。
②子类化可变类型

class SortedKeyDict(dict):
    def keys(self):
        return sorted(super(SortedKeyDict,self).keys())

(3)多重继承中方法解释顺序(MRO)
2.2之前,算法简单:深度优先,从左至右进行搜索,取得在子类中使用的属性。多重继承取找到的第一个名字。
2.2提出新的MRO,算法思想是根据每个祖先类的继承结构编译出一张列表,包括搜索到的类,按策略删除重复的。
2.3使用新的C3算法替换,采用广度优先。
新式类有__mro__属性,告诉你查找顺序。
新式类使用经典类的MRO会失败。
菱形效应
这里写图片描述
使用经典类的MRO,当实例化D时,不再得到C.__init__()之结果,而得到object.__init__()之结果。使用新式类,需要出现基类,这样在继承结构中,就形成了一个菱形。
补充:文档字符串不会从基类中继承过来。因为文档字符串对类,函数/方法,还有模块来说都是唯一的。

10、类、实例、其他对象的内建函数
(1)issubclass()
布尔函数,判断一个类是另一个类的子类或子孙类(一个类可视为其自身的子类)。

issubclass(sub,sup)

从2.3开始,第二个参数可以是可能的父类组成的元组。只要sub是其中任何一个的子类都返回True。
(2)isinstance()
布尔函数,判定一个对象是否是另一个给定类的实例。

isinstance(obj1,obj2)   

obj1是obj2的一个实例,或是obj2的子类的一个实例时,返回True。
从2.2开始,obj2可以是一个元组,obj1是obj2元组中任何一个候选类型或类的实例时,就返回True。
(3)hasattr(),getattr(),setattr(),delattr()
*attr()系列函数可工作于各种对象,不限于类和实例。
*attr(obj,’attr’….)相当于操作obj.attr。
hasattr()布尔函数,决定一个对象是否有一个特定的属性。
getattr(),setattr()相应地取得和赋值给对象的属性。getattr()会在你试图读取一个不存在的属性时,引发AttributeError异常。
delattr()删除属性。
(4)dir()
可用于实例或者类或者模块。

  • 用于实例,显示实例变量,还有在实例所在的类及所有它的基类中定义的方法和类属性。
  • 用于类,显示类及它所有基类的__dict__中的内容,但不会显示定义在元类中的类属性。
  • 用于模块,显示模块的__dict__的内容。
  • dir()不带参数时,显示调用者的局部变量。

(5)super()(2.2)
帮助程序员找出相应的父类,然后调用相关属性。
super(type[,obj])返回type的父类,传入obj参数进行父类绑定。

  • obj是一个实例,isinstance(obj,type)必须返回True;
  • obj是一个类或类型,issubclass(obj,type)必须返回True。
super(MyClass,self).__init__()

(6)vars()
与dir()相似,只是给定的对象参数都必须有一个__dict__属性。如果提供的对象没有一个这样的属性,则会引发一个TypeError异常。
vars()返回一个字典,包含存储于对象__dict__中的属性(键)和值。如果没有为vars()提供参数,将显示一个包含本地名称空间的属性(键)及其值的字典,也就是locals()。

11、用特殊方法定制类
Python特殊方法可以用来扩充类的功能,可以实现:

  • 模拟标准类型;
  • 重载操作符。

(1)Python中用来定制类的特殊方法
①基本定制型

  • C.__init__(self[,arg1,…]) 构造器(带一些可选的参数)
  • C.__new__(self[,arg1,…])构造器(带一些可选的参数);通常用在设置不变数据类型的子类
  • C.__del__(self) 解析器
  • C.__str__(self) 可打印的字符输出;内建str()及print语句
  • C.__repr__(self) 运行时的字符串输出;内建repr()和“操作符
  • C.__unicode__(self) Unicode字符串输出:内建unicode()
  • C.__call__(self,*args) 表示可调用的实例
  • C.__nonzero__(self) 为object定义False值;内建bool()
  • C.__len__(self) “长度”(可用于类);内建len()

②对象(值)比较

  • C.__cmp__(self,obj) 对象比较:内建cmp()
  • C.__lt__(self,obj) and C.__le__(self,obj) 小于/小于或等于:对应<及<=操作符
  • C.__gt__(self,obj) and C.__ge__(self,obj) 大于/大于或等于:对应>及>=操作符
  • C.__eq__(self,obj) and C.__ne__(self,obj) 等于/不等于:对应==,!=及<>操作符

③属性

  • C.__getattr__(self,attr) 获取属性:内建getattr(),仅当属性没有找到时调用
  • C.__setattr__(self,attr,val) 设置属性
  • C.__delattr__(self,attr) 删除属性
  • C.__getattribute__(self,attr) 获取属性:内建getattr(),总是被调用
  • C.__get__(self,attr) (描述符)获取属性
  • C.__set__(self,attr,val) (描述符)设置属性
  • C.__delete__(self,attr) (描述符)删除属性

④数值类型:二元操作符

  • C.__*add__(self,obj) 加:+操作符
  • C.__*sub__(self,obj) 减:-操作符
  • C.__*mul__(self,obj) 乘:*操作符
  • C.__*div__(self,obj) 除:/操作符
  • C.__*truediv__(self,obj) True除:/操作符
  • C.__*floordiv__(self,obj) Flooor除://操作符
  • C.__*mod__(self,obj) 取模/取余:%操作符
  • C.__*divmod__(self,obj) 除和取模:内建divmod()
  • C.__*pow__(self,obj[,mod]) 乘幂:内建pow(),**操作符

⑤数值类型:二进制操作符

  • C.__*lshift__(self,obj) 左移位:<<操作符
  • C.__*rshift__(self,obj) 右移位:>>操作符
  • C.__*and__(self,obj) 按位与:&操作符
  • C.__*or__(self,obj) 按位或:|操作符
  • C.__*xor__(self,obj) 按位与或:^操作符

⑥数值类型:一元操作符

  • C.__neg__(self) 一元负
  • C.__pos__(self) 一元正
  • C.__abs__(self) 绝对值,内建abs()
  • C.__invert__(self) 按位求反,~操作符

⑦数值类型:数值转换

  • C.__complex__(self,com) 转为complex(复数),内建complex()
  • C.__int__(self) 转为int,内建int()
  • C.__long__(self) 转为long,内建long()
  • C.__float__(self) 转为float,内建float()

⑧数值类型:基本表示法(String)

  • C.__oct__(self) 八进制表示,内建oct()
  • C.__hex__(self) 十六进制表示,内建hex()

⑨数值类型:数值压缩

  • C.__coerce__(self,num) 压缩成同样的数值类型,内建coerce()
  • C.__index__(self) 在有必要时,压缩可选的数值类型为整型(比如用于切片索引等)

⑩序列类型

  • C.__len__(self) 序列中项的数目
  • C.__getitem__(self,ind) 得到单个序列
  • C.__setitem__(self,ind,val) 设置单个序列元素
  • C.__delitem__(self,ind) 删除单个序列元素
  • C.__getslice__(self,ind1,ind2) 得到序列片段
  • C.__setslice__(self,ind1,ind2,val) 设置序列片段
  • C.__delslice__(self,ind1,ind2) 删除序列片段
  • C.__contains__(self,val) 测试序列成员:内建in关键字
  • C.__*add__(self,obj) 串联:+操作符
  • C.__*mul__(self,obj) 重复:*操作符
  • C.__iter__(self) 创建迭代器:内建iter()

⑪映射类型

  • C.__len__(self) mapping中项的数目
  • C.__hash__(self) 散列(hash)函数值
  • C.__getitem__(self,key) 得到给定键(key)的值
  • C.__setitem__(self,key,val) 设置给定键(key)的值
  • C.__delitem__(self,key) 删除给定键(key)的值
  • C.__missing__(self,key) 给定键如果不存在字典中,则提供一个默认值

(2)简单定制
自己实现init(),str(),repr()等。
print使用str()方法,真正的字符串对象表示使用repr()方法。

#! /usr/bin/env python
class RoundFloatManual(object):
    def __init__(self,val):
        assert isinstance(val,float),\
        "Value must be a float!"
        self.value=round(val,2)
    def __str__(self):
        return '%.2f' % self.value
    __repr__=__str__

(3)数值定制
重载__add__()方法,就重载了(+)操作符。
还可以使用__radd__()方法和__iadd__()方法。

def __add__(self,other):
    return self.__class__(self.hr+other.hr,self.min+other.min)

覆盖“原位”操作,实现增量赋值(2.0),比如iadd()支持mon+=tue。
(4)定制迭代器
实现类中的__iter__()和next()方法来创建一个迭代器。

#! /usr/bin/env python
class AnyIter(object):
    def __init__(self,data,safe=False):
        self.safe=safe
        self.iter=iter(data)
    def __iter__(self):
        return self
    def next(self,howmany=1):
        retval=[]
        for eachItem in range(howmany):
            try:
                retval.append(self.iter.next())
            catch StopIteration:
                if self.safe:
                    break
                else:
                    raise
        return retval

12、私有化
类中属性默认情况下是“公开的”,类所在模块以及导入类所在模块中的代码都可以访问到。
(1)双下划线
Python使用双下划线(__)来“混淆”属性,不允许直接访问。
混淆后的属性,会在名字前面加上下划线和类名,比如NumStr类中的__num属性,被混淆后,用于访问这个数据值的标识符就变成了self._NumStr__num。混淆操作可以防止在父类或子类中的同名冲突。
(2)单下划线
使用单下划线(_)实现简单的模块级私有化。

13、授权
(1)包装
包装任何类型作为一个类的核心成员,使新对象的行为模仿你想要的数据类型中已经存在的行为,且去掉不希望存在的行为。扩充Python是包装的另一种形式。
(2)实现授权
授权是包装的一个特性。
授权的过程即是所有更新的功能都是由新类的某部分来处理,但已存在的功能就授权给对象的默认属性。实现授权的关键点是覆盖__getattr__()方法,在代码中包含一个对getattr()内建函数的调用。

class WrapMe(object):
    def __init__(self,obj):
        self.__data=obj
    def get(self):
        return self.__data
    def __repr__(self):
        return 'self.__data'
    def __str__(self):
        return str(self.__data)
    def __getattr__(self,attr):
        return getattr(self.__data,attr)
>>>wrappedComplex=WrapMe(3.5+4j)
>>>wrappedComplex.real

访问real属性时,Python解释器将试着在局部名称空间中查找那个名字;若没有找到,会搜索类名称空间,以一个类属性访问;若还没有找到,搜素则对原对象开始授权请求,此时调用__getattr__()方法,__getattr__()方法中调用getattr()方法得到一个对象的默认行为。
总结:通过覆盖__getattr__()方法实现授权。
授权只能访问属性,特殊行为不可以。例如对列表的切片操作,它内建于类型中,不是属性,不能授权访问。
属性可以是数据属性,还可以是函数或者方法。Python所有数值类型,只有复数拥有属性:数据属性和conjugate()内建方法。

>>>wrappedList=WrapMe([123,'foo',45.67])
>>>wrrapedList[3]   #会抛出AttributeError

此时可以采用“作弊”的方法来访问实际对象和它的切片能力。

>>>realList=wrappedList.get()  #get()方法取得对原对象的访问
>>>realList[3]   

14、新式类的高级特性(2.2+)
(1)新式类的通用特性
类型和类的统一,使得可以子类化Python数据类型。同时,所有的Python内建的“casting”或转换函数现在都是工厂函数。例如:int(),long(),float(),complex;str(),unicode();list(),tuple();type()。
另外,还加入了一些新的函数:basestring();dict();bool();set(),frozenset();object();classmethod();staticmethod();super();property();file()。这些类名和工厂函数,不仅能创建这些类名的新对象,还可以用来作为基类,去子类化类型。现在还可以用于isinstance()内建函数,isinstance()函数在obj是一个给定类型的实例或其子类的实例时返回True。

OLD(not as good):
if type(obj)==type(0)...
if type(obj)==types.IntType...
BETTER:
if type(obj) is type(0)...
EVEN BETTER:
if isinstance(obj,int)...
if isinstance(obj,(int,long))...
if type(obj) is int...

(2)__slots__类属性
__dict__属性跟踪所有实例属性。
实例inst,属性foo,那么inst.foo与inst.__dict__[‘foo’]等价。
字典会占用大量内存,为内存上的考虑,可用__slots__属性替代__dict__。
__slots__是一个类变量,由一序列型对象组成。由所有合法标识构成的实例属性的集合来表示。任何试图创建一个其名不在__slots__中的名字的实例属性都将导致AttributeError异常。带__slots__属性的类定义不会存在__dict__属性了。使用__slots__属性的目的是节约内存。使用__slots__属性可以防止用户随心所欲的动态增加实例属性。

class SlottedClass(object):
    __slots__=('foo','bar')
>>>c=SlottedClass()
>>>c.foo=42
>>>c.xxx='nihao'  #引发AttributeError异常

(3)__getattribute__()特殊方法
Python类有一个__getattr__()的特殊方法,仅当属性不能在实例或类或祖先类的__dict__属性中找到时,才被调用。__getattribute__()与__getattr__()类似,不同在于,当属性被访问时,它就一直可以被调用,而不局限于不能找到的情况。在同时定义了__getattribute__()及__getattr__()方法的类中,除非明确从__getattribute__()方法调用,或者__getattribute__()方法引发了AttributeError异常,否则后者不会被调用。如果将要在__getattribute__()方法中访问这个类或其祖先类的属性,应该总是调用祖先类的同名方法,避免引起无穷递归。
(4)描述符(描述符就是可重用的属性)
可认为描述符是表示对象属性的一个代理,它为属性提供了强大的API。当需要属性时,可以通过描述符来访问它(当然还可以使用常规的句点属性标志法来访问属性)。
__get__(),__set__(),__delete__()特殊方法分别用于得到一个属性的值,对一个属性进行赋值,删除掉某个属性。同时覆盖__get__()和__set__()的类被称作数据描述符。实现了__set__()方法的类被称作非数据描述符,或方法描述符。
__get__(),__set__(),__delete__()的原型如下:

  • __get__(self,obj,typ=None)=>None
  • __set__(self,obj,val)=>None
  • __delete__(self,obj)=>None

整个描述符系统的心脏是__getattribute__()特殊方法,因为对每个属性的访问都会调用这个特殊的方法。
举例来说,给定类X和实例x:
访问实例属性,x.foo由__getattribute__()转化成:

type(x).__dict__['foo'].__get__(x,type(x))

访问类属性,那么None将作为对象被传入:

X.__dict__['foo'].__get__(None,X)

访问父类属性,super(Y,obj).foo(假设Y为X的子类):

X.__dict__['foo'].__get__(obj,X)

静态方法、类方法、属性,甚至所有的函数都是描述符。Python中函数之间的唯一区别在于调用方式的不同,分为绑定和非绑定狼类,函数描述符可以处理这些问题,描述符会根据函数的类型确定如何“封装”这个函数和函数被绑定的对象,然后返回调用对象。使用描述符的顺序很重要,有一些描述符的级别要高于其他的。描述符是一个类属性,因此所有的类属性皆具有最高的优先级。优先级排序:类属性>数据描述符>实例属性>非数据描述符>默认为__getattr__()。

#! /usr/bin/env python

import os
import pickle

class FileDescr(object):
    saved=[]

    def __init__(self,name=None):
        self.name=name

    def __get__(self,obj,typ=None):
        if self.name not in FileDescr.saved:
            raise AtrributeError,"%r used before assignment" % self.name
        try:
            f=open(self.name,'r')
            val=pickle.load(f)
            f.close()
            return val
        except(pickle.UnpicklingError,IOError,EOFError,AttributeError,ImportError,IndexError),e:
            raise AttributeError, "could not read %r" % self.name

    def __set__(self,obj,val):
        f=open(self.name,'w')       
        try:
            pickle.dump(val,f)
            FileDescr.saved.append(self.name)
        except(TypeError,pickle.PickingError),e:
            raise AttributeError, "could not pickle %r" % self.name
        finally:
            f.close()

    def __delete__(self,obj):
        try:
            os.unlink(self.name)
            FileDescr.saved.remove(self.name)
        except(OSError,ValueError),e:
            pass
>>>class MyFileValClass(object):
...         foo=FileDescr('foo')
...         bar=FileDescr('bar')
>>>fvc=MyFileVarClass()
>>>print fvc.foo  #引发AttributeError
>>>fvc.bar=42
>>>print fvc.bar  #打印42  

(5)property()内建函数
属性是一种有用的特殊类型的描述符。属性用来处理所有实例属性的访问。
使用句点符号访问实例属性,其实是在修改实例的__dict__属性。
使用property()访问实例属性,使用的是函数(或方法)。

property(fget=None,fset=None,fdel=None,doc=None)

property()接受一些传进来的函数作为参数,property()是在它所在的类被创建时被调用的,传进来的函数都是非绑定的。

class HideX(object):
    def __init__(self,x):
        assert isinstance(x,int),'"x" must be an integer!'
        self.__x=~x
    def get_x(self):
        return ~self.__x
    def set_x(self,x):
        assert isinstance(x,int),'"x" must be an integer!'
        self.__x=~x
    x=property(get_x,set_x)

改进代码==>

class AdvancedHideX(object):
    def __init__(self,x):
        assert isinstance(x,int),'"x" must be an integer!'
        self.__x=~x
    @property
    def x():
        def fget(self):
            return ~self.__x
        def fset(self,x):
            assert isinstance(x,int),'"x" must be an integer!'
            self.__x=~x
        return locals()

改进后的代码:类名称空间更加简洁;用户不能通过inst.set_x(40)来给属性赋值,只能使用init.x=4。

(6)元类和__metaclass__
元类是一个类(一个类中类),它的实例是其他的类。当创建一个新类时,就是在使用默认的元类,它是一个类型对象(传统类的元类是types.ClassType).当某个类调用type()函数时,就会看到它到底是谁的实例。元类一般用于创建类,在执行类定义时,解释器必须知道类正确的元类,所以解释器会寻找类属性的__metaclass__属性,若没找到,会向上查找父类的__metaclass__属性,如果还没找到,解释器会检查名字为__metaclass__的全局变量,若还不存在,就用types.ClassType作为此类的元类。在类定义时,将检查此类正确的元类,元类通常传递三个参数到构造器:类名,从基类继承数据的元组和(类的)属性字典。通过定义一个元类可以“迫使”程序员按照某种方式实现目标类,这样既可以简化他们的工作,也可以使编写出的程序更符合特定标准。

# coding=gbk

#! /usr/bin/env python

from warnings import warn

class ReqStrSugRepr(type):

    def __init__(cls,name,bases,attrd):
        super(ReqStrSugRepr,cls).__init__(name,bases,attrd)

        if '__str__' not in attrd:
            raise TypeError('Class requires overriding of __str__()')

        if '__repr__' not in attrd:
            warn('Class suggests overriding of __repr__()\n',stacklevel=3)

print '*** Defined ReqStrSugRepr (meta)class \n'

class Foo(object):
    __metaclass__=ReqStrSugRepr

    def __str__(self):
        return 'Instance of class:',self.__class__.__name__

    def __repr__(self):
        return self.__class__.__name__

print '*** Defined Foo Class \n'

class Bar(object):
    __metaclass__=ReqStrSugRepr

    def __str__(self):
        return 'Instance of class:',self.__class__.__name__

print '*** Defined Bar Class\n'

class FooBar(object):
    __metaclass__=ReqStrSugRepr

print '*** Defined FooBar Class\n'

14.其他模块

  • UserList 提供一个列表对象的封装类
  • UserDict 提供一个字典对象的封装类
  • UserString 提供一个字符串对象的封装类
  • types 定义所有Python对象的类型再标准Python解释器中的名字
  • operator 标准操作符的函数接口
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值