求解器在python python求解析解

一、析构方法

析构方法是指：当一个对象删除或被销毁时，python解析器也会默认调用一个方法，这个方法是 

__del__() 方法。（魔术方法之一）

#示例
class Animal(object):          #创建一个ANimal类
    def __init__(self,name):   #利用__init__方法进行初始化定义
        self.name=name
        print('这是构造初始化的方法')
    def __del__(self):
        print('这是构析方法')
        print('这在没有手动调用情况下，解析器自动调用函数来释放内存空间')
        print('%s被清理了'%self.name)
    pass
d1=Animal('旺财')
d2=Animal('咪咪')

结果：
这是构造初始化的方法
这是构析方法
这在没有手动调用情况下，解析器自动调用函数来释放内存空间
旺财被清理了
这是构造初始化的方法
这是构析方法
这在没有手动调用情况下，解析器自动调用函数来释放内存空间
咪咪被清理了

二、单继承

• 继承：和现实生活当中的继承是一样的，即子可以继承父的内容（父类的属性和行为），但值得注意的是，父类有的子类都有，但子类有的父类不一定有。
• 利用好继承可以减少代码的重复书写

#示例
class Animal(object):   #创建一个动物类，以此作为父类
    def eat(self):      #定义一个eat方法
        print('吃饭了')
        pass
    def drink(self):    #定义一个drink实例方法
        print('喝水啦')
        pass
    
class Dog(Animal):      #创建一个狗类，是子类
    def wwj(self):      #定义一个wwj实例方法
        print('小狗在叫')
        pass

class Cat(Animal):      #创建一个猫类，是子类
    def mmj(self):      #定义一个mmj实例方法
        print('小猫在叫')
        pass
    
d1=Dog()                #创建Dog类的对象d1
d1.eat()                #子类的d1拥有父类的eat方法
c1=Cat()                #创建Cat类的对象d2
c1.eat()                #子类的对象c1拥有父类的eat方法 
c1.mmj()                #子类自己的mmj方法

结果：
吃饭了
吃饭了
小猫在叫

三、多继承

• 多继承如其名所言，一个子类可以继承多个父类，拥有父类们的方法和属性。

#示例
class Animal(object):   #创建一个动物类，以此作为第一个父类
    def eat(self):      #定义一个eat实例方法
        print('大家准备吃饭了')
        
    def drink(self):
        print('大家一起喝水啦')
        
class Run(object):      #创建一个跑步类，以此作为第二个父类   
    def tiao(self):     #定义一个tiao实例方法
        print('边跑边跳起来')
        
class Dog(Animal,Run):   #创建一个狗类，以此作为子类，并且继承动物类和跑步类
    def wwj(self):       #定义一个wwj实例方法
        print('小狗在叫')
        
d1=Dog()                 #创建子类的对象d1
d1.eat()                 #子类的对象d1拥有第一个父类的eat方法
d1.tiao()                #子类的对象d1拥有第二个父类的tiao方法
d1.wwj()                 #子类的的wwj方法

三、重写父类与调用父类

• 所谓重写，就是在子类中有一个和父类相同名字的方法，导致同名的父类方法被覆盖
• 这是因为父类的方法已经不再满足子类的方法，那么我们就可以重写父类或者完善父类的方法

#示例1
class Dad(object):        #创建一个父类
    def Smoke(self):      #定义一个Smoke实例方法
        print('正在抽烟')
    def Drink(self):      #定义一个Drink实例方法
        print ('正在喝酒')
class Son(Dad):       #创建一个子类
    def Smoke(Dad):      #定义一个与父类同名的Smoke实例方法，属于重写父类的方法
        print('正在抽好烟')
d1=Son()                #创建Son的对象d1
d1.Smoke()              #调用父类的Smoke方法，但是结果会是被子类的Smoke方法给覆盖

结果：
正在抽好烟

#示例2

class Dad(object):        #创建一个父类
    def __init__(self,name,color):
        self.name=name
        self.color=color
        pass
    def Smoke(self):      #定义一个Smoke方实例法         
        print('正在抽烟')
    def Drink(self):      #定义一个Drink实例方法
        print ('正在喝酒')

class Son(Dad):       #创建一个子类
    def __init__(self):#重新写了父类__init__方法，将其变为空
        pass 
    def Smoke(Dad):      #定义一个与父类同名的Smoke实例方法，属于重写了父类的方法
        print('正在抽好烟')
d1=Son()                #创建Son的对象d1
d1.Smoke()              #调用父类的Smoke方法，但是结果会是被子类的Smoke方法给覆盖

结果：
正在抽好烟

#示例3

class Dad(object):        #创建一个父类
    def __init__(self,name,color):
        self.name=name
        self.color=color
        pass

    def Smoke(self):      #定义一个Smoke实例方法         
        print('正在抽烟')
    def Drink(self):      #定义一个Drink实例方法
        print ('正在喝酒')

class Son(Dad):       #创建一个子类
    def Smoke(Dad):      #定义一个与父类同名的方法，属于重写了父类的方法
        print('正在抽好烟')

d1=Son('茄子','yellow')   #创建Son的对象d1，并且给父类__init__方法的name和color赋值
d1.Smoke()              #调用父类的Smoke方法，但是结果会是被子类的Smoke方法给覆盖
print(d1.name)          #这里可以输出父类的__init__方法的name，但注意的是要在创建对象时赋值
                        #属于调用父类__init__方法

结果：
正在抽好烟
茄子



#示例3的另一种调用父类书写格式

class Dad(object):        #创建一个父类
    def __init__(self,name,color):
        self.name=name
        self.color=color
        pass

    def Smoke(self):      #定义一个Smoke实例方法         
        print('正在抽烟')
    def Drink(self):      #定义一个Drink实例方法
        print ('正在喝酒')

class Son(Dad):                        #创建一个子类
    def __init__(self,name,color):     #重新写了父类__init__方法，将其变为空
        Dad.__init__(self,name,color)  #调用父类__init__方法,使其具备name，color实例属性       
    def Smoke(Dad):      #定义一个与父类同名的Smoke方法，属于重写了父类的方法
        print('正在抽好烟')

d1=Son('茄子','yellow') #创建Son的对象d1，并且给父类__init__方法的name和color赋值
d1.Smoke()              #调用父类的Smoke方法，但是结果会是被子类的Smoke方法给覆盖
print(d1.name)          #这里可以输出父类的__init__方法的name，但注意的是要在创建对象时赋值
                        #属于调用父类__init__方法

结果：
正在抽好烟
茄子




#示例4

class Dad(object):        #创建一个父类
    def __init__(self,name,color):
        self.name=name
        self.color=color
        pass

    def Smoke(self):      #定义一个Smoke实例方法         
        print('正在抽烟')
    def Drink(self):      #定义一个Drink实例方法
        print ('正在喝酒')

class Son(Dad):       #创建一个子类
    
    def __init__(self,name,color):#重新写了父类__init__方法，将其变为空
        Dad.__init__(self,name,color)  #调用父类__init__方法
        self.height=161           #原来的父类中不存在的，现在这是自己拓展出来的属性
        self.weight=120           #原来的父类中不存在的，现在这是自己拓展出来的属性
    def __str__(self):
        return '{}的皮肤颜色是:{},他的身高是:{}cm，体重是:{}kg'.format(self.name,self.color,self.height,self.weight)
    def Smoke(Dad):      #定义一个与父类同名的Smoke方法，属于重写了父类的方法
        print('正在抽好烟')

d1=Son('小明','yellow')   #创建Son的对象d1，并且给父类__init__方法的name和color赋值
d1.Smoke()              #调用父类的Smoke方法，但是结果会是被子类的Smoke方法给覆盖
print(d1.name)          #这里可以输出父类的__init__方法的name，但注意的是要在创建对象时赋值
                        #属于调用父类__init__方法
print(d1)               
print(d1.__str__())     #这两种输出形式都是一样的     

结果：

正在抽好烟
小明
小明的皮肤颜色是:yellow,他的身高是:161cm，体重是:120kg
小明的皮肤颜色是:yellow,他的身高是:161cm，体重是:120kg

#示例5，利用super方法
class Dad(object):        #创建一个父类
    def __init__(self,name,color):
        self.name=name
        self.color=color
        pass

    def Smoke(self):      #定义一个Smoke实例方法         
        print('正在抽烟')
    def Drink(self):      #定义一个Drink实例方法
        print ('正在喝酒')

class Son(Dad):       #创建一个子类
    
    def __init__(self,name,color):#重新写了父类__init__方法，将其变为空
        #Dad.__init__(self,name,color)  #调用父类__init__方法
        super().__init__(name,color)#super #是自动找到父类的，进而调用其方法    
                                           #与上一行的手动调用一样结果
                                           #如果有多个父类，则会按顺序去自动查找

        self.height=161           #原来的父类中不存在的，现在这是自己拓展出来的属性
        self.weight=120           #原来的父类中不存在的，现在这是自己拓展出来的属性
    def __str__(self):
        return '{}的皮肤颜色是:{},他的身高是:{}cm，体重是:{}kg'.format(self.name,self.color,self.height,self.weight)
    def Smoke(Dad):      #定义一个与父类同名的Smoke方法，属于重写了父类的方法
        print('正在抽好烟')

d1=Son('小明','yellow')   #创建Son的对象d1，并且给父类__init__方法的name和color赋值
d1.Smoke()              #调用父类的Smoke方法，但是结果会是被子类的Smoke方法给覆盖
print(d1.name)          #这里可以输出父类的__init__方法的name，但注意的是要在创建对象时赋值
                        #属于调用父类__init__方法
print(d1)               
print(d1.__str__())     #这两种输出形式都是一样的     


结果：
正在抽好烟
小明
小明的皮肤颜色是:yellow,他的身高是:161cm，体重是:120kg
小明的皮肤颜色是:yellow,他的身高是:161cm，体重是:120kg