Python20基础 继承性

这个我多继

#面向对象编程

#继承性
class Theshy (object):
    def __init__(self,types,space):
        self.types=types
        self.space=space
    def info(self):
        s="操作风格 :{0}\n擅长位置{1}\n".format(self.types,self.space)
        return s

'''
class wo (object):
    def __init__(self,types,space,words):
        self.types=types
        self.space=space
        self.words=words

'''

#这样我们就建立了两个不同的类
#但是这两个类基本上是完全一直的
#写两个太麻烦了
#我们就可以通过继承关系来简化类的内容
#重新定义wo类
class wo (Theshy):
    def __init__(self,types,space,words):
        #super.__init__(self,types,space)
        #super().__init__(self,types,space)
        super().__init__(types,space)
        self.words=words
    def info(self):
        s="操作风格 :{0}\n擅长位置{1}\n".format(self.types,self.space)
        return s

shy=Theshy("别吃","上单")
print(shy.info())

#I=wo()
#TypeError: __init__() missing 3 required positional arguments: 'types', 'space', and 'words'
#直接报错
#是因为这里的super.__init__代替的是
#self.types=types
#self.space=space
#而不是传输的父类中的数据
#所以我们任然要手动的输入数据
#I=wo("混子","上单","就离谱")
#TypeError: descriptor '__init__' requires a 'super' object but received a 'wo'
#出错原因是上面的super是方法，需要加上()才可运行
#在修改完后继续运行
#I=wo("混子","上单","就离谱")
#TypeError: __init__() takes 3 positional arguments but 4 were given
#还是报错
#原因是super().__init__这里init的()中不用加上self了！
I=wo("混子","上单","就离谱")
print(I.info())
#这样我们就成功使用了父类Theshy中间的数据
#就减轻了负担，提高了代码的重复利用率

#我们再尝试调用一下Theshy中的info函数

class wo_2 (Theshy):
    def __init__(self,types,space,words):
        super().__init__(types,space)
        self.words=words
    def info(self):
        super().info()
        j="名台词:{0}".format(self.words)
        return j

II=wo_2("混子","上单","就离谱")
print(II.info())
#这里我们发现
#输出结果是words的"就离谱"
#这说明在父类中的info中的最后一句return s 并没有被带过来

class wo_3 (Theshy):
    def __init__(self,types,space,words):
        super().__init__(types,space)
        self.words=words
    def info(self):
        s=super().info()
        #现在我们知道了
        #这里的super().info()传输过来的是
        #"操作风格 :{0}\n擅长位置{1}\n".format(self.types,self.space)
        j="名台词:{0}".format(self.words)
        #return j+s
        #这里直接报错说没有s变量
        #现在我们在上面建立一个s
        #就可以了
        return j+s

III=wo_3("混子","上单","就离谱")
print(III.info())

class wo_4 (Theshy):
    def __init__(self,types,space,words):
        super().__init__(types,space)
        self.words=words
    def info(self):        
        #Theshy.info()
        #TypeError: info() missing 1 required positional argument: 'self'
        #只填写一个Theshy.info()后的报错结果
              
        #s=Theshy().info()
        #TypeError: __init__() missing 2 required positional arguments: 'types' and 'space'
        #修改后依然有问题，它显示缺少了两个数据types和space

        s=Theshy("混子","上单").info()
        #这样就没有报错了
        #但是这里相当于是在子类中定义了一个Theshy类的实例s
        #多此一举了
        j="\n名台词:{0}".format(self.words)
        
        #return s+j
        #这里虽然写的是s+j
        #但是返还值还是j的
        #仔细看会发现j现在是str
        #但是s却是s:str
        
        #return s
        #如果我们直接写s就返还的是s中的数据

        #return "{0}{1}".format(s,j)
        #任然没有输出s的数据

        return j+Theshy("混子","上单").info()
        #这就成功输出了
        #原因是s=Theshy("混子","上单").info()
        #他不是一个str，而是一个实例化变量

IIII=wo_4("混子","上单","就离谱")
print(IIII.info())

print("/////////////////////////////")

#重写方法
#如果子类方法和父类方法名相同，且参数列表也相同，只是方法体不同
#那么子类就可以重写父类的方法

class L_old_man(object):
    def __init__(self,dd):
        self.dd=dd

    def dede (self):
        print(self.dd)

L=L_old_man("得得得！")
L.dede()
#我们看到这里定义的dede方法
#dede方法现在输出的内容是self.dd的内容
#我们在以这个类为父类来定义一个新的类

class gaiya(L_old_man):
    def __init__(self,dd):
        super().__init__(dd)

    def dede(self):
        print("你能秒我？{0}".format(self.dd))
#我们现在以L_old_man定义成了gaiya的父类
#然后我们直接调用父类的__init__函数体
#然后我们在保证函数名和参量和父类完全一致的情况下
#对dede的函数体行了修改
LL=gaiya("得得得！")
LL.dede()
#这样我们就把父类的函数重构了

#我们知道子类可以调用父类的方法
#那么如果我们这里子类和父类方法名字一样
#只是传入参数不一样会发生什么呢？
#简单的我们直接在上面的两个类中进行修改

class L_old_man(object):
    def __init__(self,dd):
        self.dd=dd

    def dede (self):
        #错误案例
        #dd=dd*dd
        self.dd=self.dd*self.dd
        print("乘方值={0}".format(self.dd))

class gaiya(L_old_man):
    def __init__(self,dd,ddd):
        super().__init__(dd)
        self.ddd=ddd

    def dede(self):
        super().dede()

    def dede(self,ddd):
        j=self.dd
        for i  in range(ddd-1):           
            #错误案例
            #dd=dd*j
            self.dd=self.dd*j
        print("乘法值={0}".format(self.dd))

LLL=gaiya(2,5)
#LLL.dede()
#但是并不行
#他显示报错，表示缺失了ddd这个变量
#LLL.dede(5)
#然后当我们输入了ddd以后，他显示的是
#UnboundLocalError: local variable 'dd' referenced before assignment
#意思是dd不是全局变量
#那前面的那个是不是父类是否也出现了一样的问题呢？

LLLL=L_old_man(2)
#LLLL.dede()
#出现了同样的问题
#这时候我们发现可能是丢失了self的前缀
#修改完后再次运行
LLLL.dede()
#成功运行
#看来子类也是同样的问题
LLL.dede(3)
# 这样问题就解决了

print("////////////////////////////////")

#多继承
#就是一个子类有多个父类
#而如果要调用某个方法
#系统会先从子类中查找，然后再对父类，按照从左到右的次序来查找
#如果还没有找到，就会去父类的父类中，按照这个顺序继续找

class daye(object):
    def speak(self):
        print("你野爹我来了！")

class zhongdan(object):
    def speak(self):
        print("待会下来给你抓")

class shangdan(object):
    def speak(self):
        print("我TP好了")

class fuzhu(object):
    def speak(self):
        print("回来点，我点燃好了")
    
class ADC(daye,zhongdan,shangdan,fuzhu):
    pass

ADC_player=ADC()
ADC_player.speak()
#这里在ADC中没有找到speak
#于是在父类中索引的
#按照在ADC（）中写的父类顺序
#从左到右来找的

#我们再把这一串代码微调一下
class daye_2(object):
    def high_speak(self):       #这里修改了打野的方法名字
        print("你野爹我来了！")

class zhongdan_2(daye):           #这里把打野调整成了中单的父类
    def speak(self):
        print("待会下来给你抓")

class shangdan_2(zhongdan,daye):  #这里我们把打野和中单调整成了上单的父类
    def speak(self):
        print("我TP好了")

class fuzhu_2(object):
    def speak(self):
        print("回来点，我点燃好了")
    
class ADC_2(daye_2,zhongdan_2,shangdan_2,fuzhu_2):
    pass

ADC_player=ADC_2()
ADC_player.high_speak()
#这里我们调用high_speak()
#ADC_player.high_speak()
#Message=Cannot create a consistent method resolution
#order (MRO) for bases daye, zhongdan, shangdan, fuzh
#那么为什么会报错呢
#我们这里daye中只有一个方法
#而且打野中在这里是从左到右的第一个
#为什么会找不到呢？
#这里要注意的是！！！其实在索引的时候，并不是按照我们先前讲的那样

#引用Python3.86手册的内容
#对于多数应用来说，在最简单的情况下，
#你可以认为搜索从父类所继承属性的操作是深度优先、从左至右的，
#当层次结构中存在重叠时不会在同一个类中搜索两次。

#这说明，我们这里的调用方法，在深度优先从左至右的情况下
#多次跑到了同一个类中所以会出现各种问题

class daye_3(object):
    def speak_2(self):
        print("你野爹我来了！")

class zhongdan_3(object):
    def speak(self):
        print("待会下来给你抓")

class shangdan_3(object):
    def speak(self):
        print("我TP好了")

class fuzhu_3(object):
    def speak(self):
        print("回来点，我点燃好了")
    
class ADC_3(daye_3,zhongdan_3,shangdan_3,fuzhu_3):
    pass

ADC_player=ADC_3()
ADC_player.speak_2()

#好了
#问题奇奇怪怪的解决了
#我修改了所有类的名字
#让他们都变成建立一个新类
#然后就好了
#具体，，，我不知道为什么了

 

承，我也有些不明白，希望大佬如果知道为什么回复一下我，谢谢您了！