Python程序设计6——面向对象

　　面向对象有三大特征：多态(对应方法覆写)、封装、继承(对应方法重载)，这个在Java中已经说得很详细了，这里面只是介绍Python在这三个特性方面的实现。

1 创建自定义类                                                            

　　Python和Java一样使用class关键字来创建对象。语法格式如下:

class 类名:
　　def 方法名1(参数列表):
　　　　pass

　　从上述语法来看，类必须使用class关键字来定义，接着是类名，然后使用pass占位。

一个例子如下：

class Person:
    def getName(self):
        print 'My name is AIQI'
    def getAge(self):
        print 'My age is 27'
    def getHoppy(self):
        print 'My hobby is love you'
>>> import Person
>>> person = Person.Person()
>>> person.getName()
My name is AIQI
>>> person.getAge()
My age is 27
>>> person.getHoppy()
My hobby is love you

实例应用

myStr = raw_input('Please input one object:')
class MyWorld:
    #define one person method
    def printPerson(self):
        self.myTalk = 'I can speak'
        self.myLimbs = 'I can move'
        print 'I am a person so,I can %s, %s' % (self.myTalk, self.myLimbs)
    #define one pig method
    def printPig(self):
        self.myTalk = 'Hengheng...'
        self.myWeight = 'I am fat'
        print 'I am a pig so,%s, %s' % (self.myTalk, self.myWeight)
if __name__ == '__main__':
    myWorld = MyWorld()
    if myStr == 'Person':
        myWorld.printPerson()
    elif myStr == 'Pig':
        myWorld.printPig()
    else:
        print 'No this object'

运行结果：

Please input one object:Person
I am a person so,I can I can speak, I can move

2 属性和方法                                                             

　　类是忧属性和方法组成的，属性是对数据的封装，方法是对行为的描述。在Java中，属性和方法都有访问权限控制符，在python中没有这样的封装级别控制符，在Python中，构造函数、析构函数、私有属性方法、公有属性方法都是通过名称的约定来辨别的。如果函数、方法或者属性的名称以两个下划线开始，则说明为私有类型。相反，如果没有以两个下划线开始，则表示为公有属性。在Java中还有一个受保护的类型修饰符protected 在python中不存在这种类型。
　　在python中也有静态属性和实例属性。实例属性即以self作为前缀的属性，如果在类的方法中定义的变量没有使用self作为前缀声明，那么该变量就是一个普通的局部变量。

2.1 类属性                           

class Fly:
    #define one class attribute
    price = 23
    def __init__(self):
        self.direction = 'To Paris'
        speed = 32
if __name__ == '__main__':
    print Fly.price
    fly = Fly()
    print fly.direction
    Fly.price = fly.price + 10
    print 'fly,fly away'
    print 'the price increase:' + str(fly.price)
    myFly = Fly()
    print myFly.price
输出结果：
23
To Paris
fly,fly away
the price increase:33
33

　　另外方法中的局部变量speed是不能被实例及类来引用的

2.2 私有属性                        

　　将公有的实例属性direction修改成私有__direction

class Fly:
    #define one class attribute
    price = 23
    def __init__(self):
        self.__direction = 'To Paris'
        self.speed = 32
if __name__ == '__main__':
    print Fly.price
    fly = Fly()
    print fly.__direction
    Fly.price = fly.price + 10
    print 'fly,fly away'
    print 'the price increase:' + str(fly.price)
    myFly = Fly()
    print myFly.price
输出结果：
23
Traceback (most recent call last):
  File "Fly.py", line 10, in <module>
    print fly.__direction
AttributeError: Fly instance has no attribute '__direction'

　　显然报错了，也就是私有的属性不能被实例化对象访问。Python提供了直接访问私有属性的方式
实例化对象名._类名__私有属性名

class Fly:
    #define one class attribute
    price = 23
    def __init__(self):
        self.__direction = 'To Paris'
        self.speed = 32
if __name__ == '__main__':
    print Fly.price
    fly = Fly()
    print fly._Fly__direction
    Fly.price = fly.price + 10
    print 'fly,fly away'
    print 'the price increase:' + str(fly.price)
输出结果：
23
To Paris
fly,fly away
the price increase:33

2.3 数据属性                       

　　数据属性不需要预先定义，当数据属性初次被使用时，即被创建并赋值。

class DataAttribute:
    pass
if __name__ == '__main__':
    data = DataAttribute()
    data.name = 'I am not defined'
    print data.name
输出结果：I am not defined

2.4 内置属性                      

　　前面已经提到的__doc__就是内置属性。

class FatherClass:
    def __init__(self):
        self.built = 'I am the method __init__ \'s attribute'
class SonClass(FatherClass):
    def accept(self):
        self.acceptAttribute = "I am the attribute of SonClass's method accept"
if __name__ == '__main__':
    f = FatherClass()
    s = SonClass()
    print "Inherite attribute from father class:", s.built
    print "the tuple formed by base class:", SonClass.__bases__
    print "the dict formed by neizhi:", s.__dict__
    print s.__module__
    print s.__doc__
    print SonClass.__name__
输出结果：
Inherite attribute from father class: I am the method __init__ 's attribute
the tuple formed by base class: (<class __main__.FatherClass at 0x7f8d92e4ea10>,)
the dict formed by neizhi: {'built': "I am the method __init__ 's attribute"}
__main__
None
SonClass

说明：上面代码中，使用内置属性__bases__来输出其父类组成的元组。__dict__属性用例输出子类实例属性组成的字典，__module__属性用来输出当前运行的模块名称,__doc__属性用来输出doc文档，而__name__属性用例输出当前对象的类名。

2.5 类的方法                         

　　类似属性，方法也有类方法和实例方法，定义规则相同，在Java中用static来定义，而python中没有static关键字，而是使用函数staticmethod()或者@staticmethod指令的方式来定义静态方法。

2.5.1 类方法         

class Methods:
    @staticmethod
    def myMethod():
        print 'This is a static method'
    def __myMethod():
        print 'This is a private method'
    def getMyMethod():
        print 'I willbe converted to static method'
    conversion = staticmethod(getMyMethod)
    conPrivate = staticmethod(__myMethod)
if __name__ == '__main__':
    methods = Methods()
    methods.myMethod()
    Methods.myMethod()
    #访问转换为静态方法后的原有方法
    methods.conversion()
    Methods.conversion()
    methods.conPrivate()
    Methods.conPrivate()
输出结果：
This is a static method
This is a static method
I willbe converted to static method
I willbe converted to static method
This is a private method
This is a private method

　　上面代码中，在类Methods中分别声明了一个静态方法myMethod，一个私有方法__myMethod和一个普通方法getMyMethod，然后用函数staticmethod()将普通方法getMyMethod转换为静态方法conversion，将私有方法__myMethod转换为静态方法conPrivate

2.5.2 内置方法     

　　有许多类内置的方法，这些方法可能会被封装起来被别的函数调用。

 

下面介绍几个重要的__init__方法
1.__init__方法
　　这个方法在Python中是构造函数，与Java不同的是，Java中的构造函数和类名是一样的，Python中不必如此，实际上构造函数更严谨的说法是初始化函数，所以__init__还是可以的。

class People:
    def __init__(self, name):
        self.name = name
    def sayHi(self):
        print 'Hello, My name is:', self.name
p = People('AiQi')
p.sayHi()
输出结果：Hello, My name is: AiQi

2.__del__方法
　　__del__方法的主要作用是释放被占用的资源，在Python中是析构函数。
　　所谓析构函数是：析构函数(destructor) 与构造函数相反，当对象脱离其作用域时（例如对象所在的函数已调用完毕），系统自动执行析构函数。析构函数往往用来做“清理善后” 的工作（例如在建立对象时用new开辟了一片内存空间，应在退出前在析构函数中用delete释放）。

class Room:
    count = 0
    def __init__(self, name):
        self.name = name
        print 'Initing, name is %s' % self.name
        Room.count += 1
    def __del__(self):
        print '%s say byebye:' % self.name
        Room.count -= 1
        if Room.count == 0:
            print 'I am the last one'
        else:
            print 'There is %d persons left' % Room.count
    def sayHi(self):
        print 'Hello,My name is %s ' % self.name
    def howMany(self):
        if Room.count == 1:
            print 'I am the last one'
        else:
            print 'There is %d persons left' % Room.count
if __name__ == '__main__':
    room = Room('AiQi')
    room.sayHi()
运行结果：
Initing, name is AiQi
Hello,My name is AiQi 
I am the last one
Initing, name is Ren
Hello,My name is Ren 
There is 2 persons left
AiQi say byebye:
There is 1 persons left
Ren say byebye:
Exception AttributeError: "'NoneType' object has no attribute 'count'" in <bound method Room.__del__ of <__main__.Room instance at 0x7fc513263200>> ignored
AiQi say byebye:
Exception AttributeError: "'NoneType' object has no attribute 'count'" in <bound method Room.__del__ of <__main__.Room instance at 0x7fc5132631b8>> ignored

3. __new__方法
　　__new__方法在创建对象时被调用，返回当前对象的一个实例。看起来和__init__方法没有什么区别。实际上，__init__方法在创建完对象之后才被调用，对当前对象的实例进行初始化，而__new__方法则是在创建对象时被调用的。

class MyNew:
    def __init__(self):
        print ("__init__")
    def __new__(self):
        print ("__new__")
if __name__ == '__main__':
    myNew = MyNew()

4.__setitem__方法
　　_setitem__专用方法的含义是进行赋值时，创建字典对象

class MySetitem:
    def __setitem__(self, key, value):
        print 'key=%s, value=%s' % (key, value)
mySetitem = MySetitem()
mySetitem['a'] = 'Alice'
mySetitem['b'] = 'Quinta'
mySetitem['c'] = 'Amy'
执行结果：
key=a, value=Alice
key=b, value=Quinta
key=c, value=Amy

5.__getitem__方法
　　__getitem__用于返回字典的值。这两个方法和java的setter和getter方法是类似的。
6.__delitem__方法
　　__delitem__方法是在调用"del 实例对象[key]"语句时调用。

class MyDelitem:
    def __delitem__(self, key):
        print 'delete item:%s' % key
myDelitem = MyDelitem()
del myDelitem['dcy']
输出结果：delete item:dcy

7.__cmp__方法
　　这个内置方法被封装用于给==比较累实例时候进行调用。

class MyCmp:
    def __cmp__(self, other):
        print '__cmp__ is called'
        return 0
if __name__ == '__main__':
    mycmp1 = MyCmp()
    mycmp2 = MyCmp()
    print mycmp1 == mycmp2
输出：
__cmp__ is called
True

2.6 方法的动态特性               

 

　　python语言是一种完全面向对象的动态语言，主要体现在：可以动态添加类的方法，将某个已经定义的方法添加到类中。如果类本身已经有了同名的方法，那么将会替换掉类中的方法体。

 

class_name.method_name = exist_name
class Yesterday:
    pass
def today(self):
    print 'Today is a nice day'
if __name__ == '__main__':
    Yesterday.yesterday = today
    yes = Yesterday()
    yes.yesterday()
输出结果：Today is a nice day

 

3 继承                                                              

 

　　继承是子类继承父类的属性和方法，python中没有extends关键字，用括号

 

class class_name(father_class_name)
一个例子：

 

 

3.1 super调用父类方法         

 

　　python支持用super关键字来调用父类的方法

 

'''
Created on 2013-8-6

@author: Landau
'''
class Father:
    def __init__(self):
        print 'I am the __init__ of father'
        print 'Use later'
class Son(Father):
    def __init__(self):
        print 'I am the __init__ of son'
        Father.__init__(self)
b = Son()

 

　　我们也可以使用super关键字来实现上面的功能

 

 

3.2 多继承                          

 

　　python允许多重继承。语法格式如下：
class class_name(fatherclass1_name,fatherclass2_name)
　　多继承是这样的，比如一个人，眼睛像妈妈，肤色像爸爸。这就是多继承。

 

 

 

 

3.3 类的命名空间                 

 

　　类和类成员的名称是丰富的，为了描述一个具体的对象，需要对类和类成员进行设计，在设计类和类成员过程中，难免会出现类的名称或类成员中的方法相同的情况，这样就会造成代码混乱，从而使代码的可读性降低。使用命名空间可以解决此问题。
　　在java中，我们只要把类放到各自的包中，就可以避免类的名称或者类成员重复了，我们可以认为package是java的命名空间。
　　在python中，定义类时，所有位于class语句中的代码都在特殊的命名空间中执行，该命名空间被称为类命名空间(class namespace)。这个类命名空间不仅可以被类中所有成员访问，还可以被类的实例方法访问。

 

3.4 继承检查                        

 

　　python提供了内建的issubclass函数用于继承检查

 

 

　　issubclass函数的第一个参数是子类，第二个参数是可能的父类，类似还有一个函数isinstance，用于检查一个对象是不是一个类的实例，第一个参数是对象，第二个参数是可能的类。

 

3.5 新式类                            

 

　　新式类是指从python2.2开始引入的类。通常情况下，从object或者其他内置类型衍生的类，都被称为新式类。
__slots__类属性
　　这个类属性用于替代__dict__属性
　　__slots__是一个类变量，可以由一系列对象组成，使用所有合法标识构成的实例属性的集合来表示。它也可以是一个列表、元组或可迭代对象，总之，任何试图创建一个其名不在__slots__中的实例属性的操作都将引发AttributeError异常，而且实例属性必须初始化。
　　一般情况下，__slots__类属性在class语句顶层设置。下面通过一个例子说明：

 

class MyLimiter(object):
    __slots__ = 'my_name', 'my_age', 'my_hobby'
if __name__ == '__main__':
    x = MyLimiter()
    x.my_name = 'AiQi'
    print x.my_name