Python 继承
2021-07-11 06:06
标签：派生 ase dog 选择 方式 运行 参数 serve lis 何为继承？ 继承是一种创建新类的方式，在python中，新建的类可以继承一个或多个父类，父类又可称为基类或超类，新建的类称为派生类或子类。 先举一个例子，如： 从上面可以看出，cat与dog类为子类，而animal为父类，当实例化cat类调用yell方法时，首先会去子类中寻找，当找不到时，再去父类中寻找，从而调用。实例化dog类也是一样。 从上面分析可知： 当子类当中有被调用的方法时，子类的对象会直接选择子类中的方法，变量，父类中的方法不会被自动执行 如果我们既要想执行子类方法，又想执行父类的方法，那么需要在子类的方法中调用父类的方法： 父类名.方法名(self,...(参数))super().方法名((没有self)...(参数)) 上面使用的好处：可以帮助我们在子类中调用父类中的同名方法 面试题： 下面几道题为面试常考题，进行分析下： 多继承 什么是多继承？多继承可表示为： 上式中，Son类为子类，父类为：Parent1与Parent2。在该继承方式中，Son类同时继承了两父类其查询方式又是怎样的呢？ 再举一个例子： 说明： Python 继承 标签：派生 ase dog 选择 方式 运行 参数 serve lis 原文地址：https://www.cnblogs.com/colin1314/p/9551215.htmlclass 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()
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)
# 例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 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() # 上面执行完了，重新执行该语句
上一篇：Python递归和循环的效率比较
下一篇：python之数据类型