2 Python 面向对象

1 类

用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。

1.1 类的基本介绍

class Person(object):   #类关键字class
    
    #类变量，在所有实例之间共享
    head = '头'      
    body = '身体'
    arm = '胳膊'
    leg = '腿'
    
    #无参构造函数,类被实例化时调用
    def __init__(self):
        self.__name = '张飞'      #self指类的实例
        self.__age = 0           #__表示私有变量
        
    #自定义函数，获取名字
    def getName(self):
        return self.__name
    
    #自定义函数，获取年龄
    def getAge(self):
        return self.__age
    
#类的实例化
zhang = Person()
print '张有 ' + zhang.head + zhang.body + zhang.arm + zhang.leg   #类变量使用
print '张的名字是： ' + zhang.getName()       #自定义函数使用
print '张的年龄是： ' + str(zhang.getAge())

#结果
张有： 头身体胳膊腿
张的名字是： 张飞
张的年龄是： 0

1.2 静态属性及方法

class Person(object):   
    
    #静态变量
    head = '头'      
    body = '身体'
    arm = '胳膊'
    leg = '腿'
    
    #有参构造函数,类被实例化时调用
    def __init__(self , name , age):
        self.__name = name      #self指类的实例
        self.__age = age        #__表示私有变量
        
    #自定义函数，获取名字
    def getName(self):
        return self.__name
    
    #自定义函数，获取年龄
    def getAge(self):
        return self.__age
    
    #静态方法
    @staticmethod
    def eat():
        return '开始吃饭'
    
#类的实例化
zhao = Person('赵云' , 20)
print '张的名字是： ' + zhao.getName()       #自定义函数使用
print '张的年龄是： ' + str(zhao.getAge())
print Person.head       #静态变量使用
print Person.eat()      #静态方法使用

#结果
张的名字是： 赵云
张的年龄是： 20
头
开始吃饭

 1.3 property装饰器

可以把一个 方法 变成 属性 来调用

class Person(object):   

    def __init__(self):
        self.__name = '张飞'          
        
    @property
    def name(self):
        return self.__name
    
    @name.setter
    def name(self , name):
        self.__name = name
    
#类的实例化
zhao = Person()
print '名字是： ' + zhao.name     #property get方法
zhao.name = '赵云'                 #property set方法
print '名字是： ' + zhao.name

#结果
名字是： 张飞
名字是： 赵云

 1.4 构造函数和析构函数

构造函数：新建对象时做初始化工作

析构函数：销毁对象时做清理工作，如：释放内存等

当对象被创建时， 就创建了一个引用计数， 当这个对象不再需要时， 也就是说， 这个对象的引用计数变为0 时， 它被垃圾回收。

但是回收不是"立即"的， 由解释器在适当的时机，将垃圾对象占用的内存空间回收。

class Person(object):   

    def __init__(self):
        print '构造函数'          
        
    def __del__(self):
        print '析构函数'
    
#类的实例化
p = Person()

#结果
构造函数
析构函数

 1.5 继承

#构造函数无参--------------------------------------------------
class Person(object):
    
    #类变量，在所有实例之间共享
    head = '头'      
    body = '身体'
    arm = '胳膊'
    leg = '腿'
    
    def __init__(self):      
        print 'Person class'
        
    #自定义函数，获取名字
    def getName(self):
        return '赵云'
    
    #自定义函数，获取年龄
    def getAge(self):
        return 18
    
    #习惯类
    def habit(self):
        print '父类坏习惯：喝酒'
    
class Student(Person): #继承Person类
    
    def __init__(self):
        super(Student , self).__init__()    #调用父类构造方法
        print 'Student class'
        
    #子类习惯类
    def habit(self):
        Person.habit(self)  #调用父类方法
        print '子类坏习惯：抽烟'
    
#类的实例化
s = Student()
print Student.head
print s.getName()
s.habit()

#结果
Person class
Student class
头
赵云
父类坏习惯：喝酒
子类坏习惯：抽烟

#构造函数有参--------------------------------------------------
class Person(object):
       
    def __init__(self , name , age):
        self.__name = name      
        self.__age = age        
        print 'Person class'
        
    #自定义函数，获取名字
    def getName(self):
        return self.__name
    
    #自定义函数，获取年龄
    def getAge(self):
        return self.__age
    
    #习惯类
    def habit(self):
        print '父类坏习惯：喝酒'
    
class Student(Person): #继承Person类
    
    def __init__(self , name , age):
        print 'Student class'
        super(Student , self).__init__(name , age) #调用父类构造函数
    
    #子类习惯类
    def habit(self):
        Person.habit(self)  #调用父类方法
        print '子类坏习惯：抽烟'
    
#类的实例化
s = Student('小明' , 20)
s.habit()

#结果
Student class
Person class
父类坏习惯：喝酒
子类坏习惯：抽烟

 1.6 多继承

经典类：深度优先

新式类：广度优先

#经典类----------------------------------------------------------------
#实例调用say()，python搜索顺序grandson->father
#实例调用eat()，python搜索顺序grandson->father->grandfather
#虽然grandson也继承uncle，但是并没有调用uncle的eat()
class grandfather():    #经典类
    def say(self):
        print 'grandfather say'
        
    def eat(self):
        print 'grandfather eat'
        
class father(grandfather):
    def say(self):
        print 'father say'
    
class uncle(grandfather):
    def eat(self):
        print 'uncle eat'
    
class grandson(father , uncle):
    pass
        
gs = grandson()
gs.say()
gs.eat()

#结果
father say
grandfather eat

#新式类----------------------------------------------------------------
#实例调用say()，python搜索顺序grandson->father
#实例调用eat()，python搜索顺序grandson->father->uncle
class grandfather(object):    #新式类
    def say(self):
        print 'grandfather say'
        
    def eat(self):
        print 'grandfather eat'
        
class father(grandfather):
    def say(self):
        print 'father say'
    
class uncle(grandfather):
    def eat(self):
        print 'uncle eat'
    
class grandson(father , uncle):
    pass
        
gs = grandson()
gs.say()
gs.eat()

#结果
father say
uncle eat

 1.7 接口

python 没有抽象类、接口的概念，需要abc.py 这个类库来帮助实现

from abc import ABCMeta, abstractmethod

class father():
    __metaclass__ = ABCMeta
    
    @abstractmethod
    def say(self):pass
    
class son(father):
    def say(self):
        print 'son say'
        
son = son()
son.say()

#结果
son say

 2 异常

在Python中，无法正常处理程序时就会发生一个异常。发生异常时我们需要捕获处理它，否则程序会终止执行。