class Animal:
def __init__(self,name,sex,age):
self.name = name
self.sex = sex
self.age = age
class Person:
def __init__(self,name,sex,age):
self.name = name
self.sex = sex
self.age = age
class Cat:
def __init__(self,name,sex,age):
self.name = name
self.sex = sex
self.age = age
class Dog:
def __init__(self,name,sex,age):
self.name = name
self.sex = sex
self.age = age
p1 = Person(‘alex‘,‘laddyboy‘,1000)
class Animal:
breath = ‘呼吸‘
def __init__(self, name, sex, age):
self.name = name
self.sex = sex
self.age = age
def eat(self):
print(self)
print(‘动物都需要进食....‘)
class Person(Animal): # 括号里面的 父类,基类,超类 括号外面的 子类,派生类.
pass
class Cat:
pass
class Dog:
pass
p1 = Person(‘alex‘, ‘laddyboy‘, 1000)
print(p1.__dict__)
# 初识继承:
# 子类以及子类实例化的对象 可以访问父类的任何方法或变量.
# 类名可以访问父类所有内容
# print(Person.breath)
# Person.eat(111)
# 子类实例化的对象也可以访问父类所有内容
# print(p1.breath)
# print(p1)
# p1.eat()
# 写三个类: 狗,猫,鸡, 每个类中都有 吃 喝 自己的方法 最后定义一个Animal类,
class Animal:
def __init__(self, name, sex, age):
self.name = name
self.sex = sex
self.age = age
def eat(self,a1):
print(‘%s吃%s‘ % (self.name,a1))
def drink(self):
print(‘%s喝东西‘ % (self.name))
class Cat(Animal):
def miaow(self):
print(‘喵喵叫‘)
# def eat(self): # 只执行自己类中的方法
# print(666)
class Brid(Animal):
def __init__(self, name,sex,age,wing): # self b1对象 name ‘鹦鹉‘,sex ‘公‘,age 20, wing ‘绿翅膀‘
‘‘‘
self=b1对象
name=‘鹦鹉‘
sex=‘公‘
age= 20,
wing=‘绿翅膀‘
‘‘‘
# Animal.__init__(self, name, sex, age)
super().__init__(name,sex,age) # super(Brid,self).__init__(name,sex,age)
self.wing = wing
def bark (self):
print(‘嗷嗷叫‘)
def eat(self,argv):
super().eat(argv)
print(‘鸟吃虫子...‘)
class Chook(Animal):
def crow(self):
print(‘大爷laiwanya‘)
# cat1 = Cat(‘tom‘,‘公‘, 3)
# # cat1.eat()
# 只执行父类的方法:子类中不要定义与父类同名的方法
# 只执行子类的方法:在子类创建这个方法.
# 既要执行子类的方法,又要执行父类的方法?
# 有两种解决方法.
# 1,Animal.__init__(self, name, sex, age)
# 1,super().__init__(name,sex,age)
# cat1 = Cat(‘tom‘,‘公‘, 3,)
#
# b1 = Brid(‘鹦鹉‘,‘公‘,20,‘绿翅膀‘)
# print(b1.__dict__)
# b1.eat(‘金蝉‘)
# 继承的进阶
# 继承: 单继承,多继承.
# 类: 经典类, 新式类
# 新式类: 凡是继承object类都是新式类.
# python3x 所有的类都是新式类,因为python3x中的类都默认继承object.
# class A:
# pass
# 经典类: 不继承object类都是经典类
#python2x:(既有新式类,又有经典类) 所有的类默认都不继承object类,所有的类默认都是经典类.你可以让其继承object.
# 单继承: 新式类,经典类查询顺序一样.
class A:
pass
# def func(self):
# print(‘IN A‘)
class B(A):
pass
# def func(self):
# print(‘IN B‘)
class C(B):
pass
# def func(self):
# print(‘IN C‘)
c1 = C()
c1.func()
# 多继承:
# 新式类: 遵循广度优先.
# 经典类: 遵循深度优先.
# 多继承的新式类
广度优先 : 一条路走到倒数第二级,判断,如果其他路能走到终点,则返回走另一条路.如果不能,则走到终点.
class A:
def func(self):
print(‘IN A‘)
class B(A):
pass
# def func(self):
# print(‘IN B‘)
class C(A):
pass
# def func(self):
# print(‘IN C‘)
class D(B):
pass
# def func(self):
# print(‘IN D‘)
class E(C):
pass
# def func(self):
# print(‘IN E‘)
class F(D,E):
pass
# def func(self):
# print(‘IN F‘)
f1 = F()
f1.func()
class A:
def func(self):
print(‘IN A‘)
class B(A):
pass
# def func(self):
# print(‘IN B‘)
class C(A):
pass
# def func(self):
# print(‘IN C‘)
class D(B):
pass
# def func(self):
# print(‘IN D‘)
class E(C):
def func(self):
print(‘IN E‘)
class F(D,E):
pass
# def func(self):
# print(‘IN F‘)
f1 = F()
f1.func()
print(F.mro()) # 查询类的继承顺序
# 多继承的经典类 深度优先 : 一条路走到底.
class A:
pass
# def func(self):
# print(‘IN A‘)
class B(A):
pass
# def func(self):
# print(‘IN B‘)
class C(A):
# pass
def func(self):
print(‘IN C‘)
class D(B):
pass
# def func(self):
# print(‘IN D‘)
class E(C):
# pass
def func(self):
print(‘IN E‘)
class F(D,E):
pass
# def func(self):
# print(‘IN F‘)
f1 = F()
f1.func()
简单总结:
继承的优点:
1. 优化代码,节省代码.
2. 提高代码的复用性.
3. 提高代码的维护性.
4. 让类与类之间发生关系.
组合: 让对象与对象发生关系.
初识继承:
只执行本类的方法
只执行父类的方法.
既执行本类又执行父类的方法
父类名.方法名(参数)
super().方法名(参数(self自动传值))
单继承,多继承.
类:新式类,经典类.
单继承;
新式类经典类一样.
多继承:
新式类:广度优先 类名.mro() 新式类.
经典类:深度优先.
习题
1.
# a,定义一个父类Animal，在构造方法中封装三个属性，姓名，性别，年龄，
# 再给其添加一个eat的方法，方法中显示%s正在吃饭（%s是哪个对象调用此方法，显示哪个对象名字）。
# b,定义两个子类Person,Dog，全部继承这个父类Animal.
# c,Person类中，有构造方法，封装一个皮肤的属性，有eat方法，方法中显示人类正在吃饭。
# d,Dog类中，有构造方法，封装一个毛色的属性，有eat方法，方法中显示狗狗正在吃饭。
# 上面这几个类创建完成之后，完成下列要求：
# ①： 实例化一个人类的对象，让其只封装皮肤属性。
# ②： 实例化一个人类的对象，让其封装姓名，性别，年龄，皮肤四个属性。
# ③： 实例化一个狗类的对象，让其只封装毛色属性。
# ④： 实例化一个狗类的对象，让其封装姓名，性别，年龄，毛色四个属性。
# ⑤： 实例化一个人类的对象，让其只执行父类的eat方法（可以对人类代码进行修改）。
# ⑥： 实例化一个狗类的对象，让其既执行父类的eat方法，又执行子类的eat方法。
class Animal:
def __init__(self,name,sex,age):
self.name = name
self.age = age
self.sex = sex
def eat(self):
print(‘%s 在吃东西‘ % self.name)
class Person(Animal):
def __init__(self,name,sex,age,skin):
super().__init__(name,sex,age)
self.skin = skin
def eat(self):
print(‘人类正在吃饭‘)
class Dog(Animal):
def __init__(self,coat_colour):
self.coat_colour = coat_colour
def eat(self):
print(‘狗狗正在吃饭‘)
p1 = Person(‘李富贵‘,‘男‘,18,‘黄皮肤‘)
print(p1.__dict__)
2.
class E:
def func(self):
print(‘in E‘)
class A(E):
def func(self):
print(‘in A‘)
class B:
def func(self):
print(‘in B‘)
class C(A,B):
def func(self):
super(A,self).func()
print(‘in C‘)
可以改动上上面代码，完成下列需求：
对C类实例化一个对象产生一个c1，然后c1.func()
c1 = C()
c1.func()
1, 让其执行C类中的func
2，让其执行A类中的func
3，让其执行B类中的func
4，让其既执行C类中的func，又执行A类中的func
5，让让其既执行C类中的func，又执行B类中的func
3.
# 3，下面代码执行结果是什么？为什么？
class Parent:
def func(self):
print(‘in Parent func‘)
def __init__(self):
self.func()
class Son(Parent):
def func(self):
print(‘in Son func‘)
son1 = Son()
in Son func
4.
class A:
name = []
p1 = A()
p2 = A()
p1.name.append(1)
print(p1.name)
print(p2.name)
print(A.name)
# p1.name，p2.name，A.name 分别又是什么？为什么？
[1]
[1]
[1]
5.
class A:
name = ‘alex‘
p1 = A()
p2 = A()
p1.name = ‘wusir‘
print(p1.name)
print(A.name)
#p1.name,A.name分别又是什么?
wusir
alex
原文：https://www.cnblogs.com/skydragon/p/11674477.html