标签：派生 ase dog 选择 方式 运行 参数 serve lis
何为继承？
继承是一种创建新类的方式，在python中，新建的类可以继承一个或多个父类，父类又可称为基类或超类，新建的类称为派生类或子类。
先举一个例子，如：
class animal: def __init__(self,name,kind,food,language): self.name = name self.kind = kind self.food = food self.language = language def yell(self): print(‘%s叫‘ % self.language) def eat(self): print(‘吃%s‘ % self.food) def drink(self): print(‘喝水‘) class cat(animal): def catch_mouse(self): print(‘抓老鼠‘) class dog(animal): def look_after_house(self): print(‘看家‘) Ali = cat(‘Ali‘, ‘bosi_cat‘, ‘fish‘, ‘miaomiao‘) Jingang = dog(‘Jingang‘,‘aisijimo_dog‘, ‘paigu‘, ‘wangwang‘) Ali.yell() Ali.catch_mouse() Ali.drink() Jingang.yell() Jingang.eat() Jingang.look_after_house()
从上面可以看出，cat与dog类为子类，而animal为父类，当实例化cat类调用yell方法时，首先会去子类中寻找，当找不到时，再去父类中寻找，从而调用。实例化dog类也是一样。
class animal: def __init__(self, name, kind, food, language): # print(‘in animal‘) self.name = name self.king = kind self.food = food self.language = language def yell(self): print(‘%s叫‘% self.language) def eat(self): print(‘吃%s‘ % self.food) def drink(self): print(‘喝水‘) class cat(animal): def __init__(self, name, kind, food, language, eye_color): # print(‘in cat‘) self.eye_color = eye_color # 派生类属性 # animal.__init__(self, name, kind, food, language) # 调用父类的方法 super().__init__(name,kind,food,language) # 调用父类 __init__ def catch_mouse(self): print(‘抓老鼠‘) def eat(self): # 不仅执行了父类中的基础功能，还完成了特殊的功能 animal.eat(self) super().eat() self.weight = 10 # 方法内定义属性 class dog(animal): def look_after_house(self): print(‘看家‘) def eat(self): animal.eat(self) super().eat() self.drink() Ali = cat(‘Ali‘, ‘bosi_cat‘, ‘fish‘, ‘miaomiao‘,‘绿色‘) print(Ali.food) Ali.eat() Ali.catch_mouse() print(Ali.weight)
从上面分析可知：
当子类当中有被调用的方法时，子类的对象会直接选择子类中的方法，变量，父类中的方法不会被自动执行
如果我们既要想执行子类方法，又想执行父类的方法，那么需要在子类的方法中调用父类的方法：
父类名.方法名(self,...(参数))super().方法名((没有self)...(参数))
上面使用的好处：可以帮助我们在子类中调用父类中的同名方法
面试题：
下面几道题为面试常考题，进行分析下：
# 例1 class Foo: def __init__(self): self.func() def func(self): print(‘in Foo‘) class Son(Foo): def func(self): print(‘in Son‘) s1 = Son() # in Son
# 解题思路：
1 将Son类实例化给s1
2 在son类中寻找__init__方法，如果没有，就去父类Foo中寻找
3 自动执行父类中的__init__方法，此时，self始终为s1，因此，该内部调用的方法为:s1.func()
4 返回到Son类中，打印输出‘in Son‘
# 例2： class Foo: Country = ‘China‘ def func(self): print(self.Country) class Son(Foo): Country = ‘English‘ def func(self): # 走这个方法 print(self.Country) s = Son() s.func() # English
# 例3： class Foo: Country = ‘China‘ def func(self): # 走这个方法 print(self.Country) class Son(Foo): Country = ‘English‘ s = Son() s.func() # English
# 解题思路：
1 实例化对象s,开辟类对象空间存储属性 即Country = ‘English‘
2 调用子类空间func()函数，若没有，去父类去寻找，
3 此时父类中的self为实例化对象s,因此，打印输出的为：English
# 例4： class Foo: Country = ‘China‘ def func(self): print(self.Country) class Son(Foo):pass s = Son() s.func() # ‘China‘
解题思路：
1 同上，子类中没有属性与方法
2 调用父类属性与方法，进行输出
多继承
什么是多继承？多继承可表示为：
class Parent1:pass class Parent2:pass class Son(Parent1,Parent2):pass print(Son.__bases__) # (<class ‘__main__.Parent1‘>, <class ‘__main__.Parent2‘>)
上式中，Son类为子类，父类为：Parent1与Parent2。在该继承方式中，Son类同时继承了两父类其查询方式又是怎样的呢？
class F1: def a(self): print(‘F1.a‘) class F2: def a(self): print(‘F2.a‘) class S(F1,F2): pass obj = S() obj.a() # F1.a
class F0: def a(self): print(‘F0.a‘) class F1(F0): def a1(self): print(‘F1.a‘) class F2: def a(self): print(‘F2.a‘) class S(F1,F2): pass obj = S() obj.a() # F0.a
运行下查找顺序：
python中支持多继承
a. 左侧优先
b. 一条道走到黑
c. 有同一个根时，根最后执行
class Base(): def a(self): print(‘Base.a‘) class F0(Base): def a(self): print(‘F0.a‘) class F1(F0): def a1(self): print(‘F1.a‘) class F2(Base): def a(self): print(‘F2.a‘) class S(F1,F2): pass obj = S() obj.a()
再举一个例子：
class RequestHandler(): def serve_forever(self): print(‘RequestHandler.serve.forever‘) self.process_request() def process_request(self): print(‘process_request.process_request‘) class Minx: def process_request(self): print(‘minx.process_request‘) class Son(Minx, RequestHandler): pass obj = Son() obj.serve_forever()
说明：
函数内部self 指的就是对象obj。因此，在调用obj.serve_forever()时候，首先在派生类Son中找有没有serve_forever()函数，
若没有，则去Son中的父类Minx类去找，也没有后，在返回到父类RequestHandler（）中去找，找到后执行并打印，当运行到
self.process_request()函数时，此时self 不是RequestHandler()函数内部的process_request(self)，而是obj对象的的self，
即Son类的self,因此，又得重新从派生类按顺序去寻找process_request()函数，最后在父类Minx中找到！
class BaseRequest: def __init__(self): print(‘BaseRequest.init‘) class RequestHandler(BaseRequest): def __init__(self): print(‘RequestHandler.init‘) BaseRequest.__init__(self) # 执行父类的__init__(self) def serve_forever(self): print(‘RequestHandler.serve.forever‘) self.process_request() def process_request(self): print(‘process_request.process_request‘) class Minx: def process_request(self): print(‘minx.process_request‘) class Son(Minx, RequestHandler): pass obj = Son()
默认执行__init__(self)函数，因此在子类或着父类中按顺序寻找该函数
obj.serve_forever() # 上面执行完了，重新执行该语句
标签：派生 ase dog 选择 方式 运行 参数 serve lis
原文地址：https://www.cnblogs.com/colin1314/p/9551215.html
