1 class A:
 2     # 父类中的方法和属性
 3     a = 1
 4     def a1(self):
 5         print('a1')
 6
 7 class B(A):
 8     # 子类中的方法和属性
 9     pass
10 b = B()  # 实例化子类B的对象b
11 print(b.a)  # 使用父类A中的属性
12 b.a1()  # 使用父类A中的方法

 1 # 属性的查找顺序
 2 class A:  # 父类A定义了一个x
 3     x = 1
 4
 5 class B(A):  # 子类B也定义了一个x
 6     x = 2
 7
 8 b = B()
 9 print(b.x)  # 在对象定义之前查找是查找子类B中
10 b.x = 3  # 对象也定义了一个x
11 print(b.x)  # 定义x之后,是在对象的属性中查找

 1 # 派生类
 2 class Person:
 3     def say_hi(self):  # 父类中有一个方法
 4         print('hi')
 5
 6 class Student(Person):
 7     def say_hello(self):  # 子类中也有一个新的方法
 8         print('hello')  # 此时这个子类就叫做派生类
 9
10 s1 = Student()  # 实例化一个类的对象
11 s1.say_hi()  # 子类的对象可以调用父类的方法
12 s1.say_hello()

 1 # 覆盖
 2 class Person:
 3     x = 1  # 父类中有一个属性
 4     def say_hi(self):  # 父类中有一个方法
 5         print('hi')
 6
 7 class Student(Person):
 8     x = 2  # 子类中有一个同名的属性
 9     def say_hi(self):  # 子类中也有一个同名的方法
10         print('hello')
11
12 s1 = Student()
13 print(s1.x)  # 打印的是子类中的属性
14 s1.say_hi()  # 打印的是子类中的方法

语法:
```python
方式1:
super(当前类名称,self).你要调的父类的属性或方法
方式2:
super().你要调的父类的属性或方法
方式3:
类名称.你要调的父类的属性或方法(self)
#方式3与继承无关
```

 1 # 子类访问父类的内容
 2 class Person:
 3     def __init__(self,name,age):
 4         self.name = name
 5         self.age = age
 6
 7     def eat(self):
 8         print('%s会吃东西'%self.name)
 9
10 class Student(Person):
11     def __init__(self,name,age,id):
12         # 第一种,父类名直接调用,这种方法什么地方都可以调用,与继承无关,并且需要写上对象本身
13         Person.__init__(self,name,age)
14         # 第二种,super(类名,对象本身),是python2内置的
15         super(Student,self).__init__(name,age)
16         # 第三种,python3做了优化可以内部不传参,推荐使用
17         super().__init__(name,age)
18         self.id = id
19
20     def eat(self):
21         super().eat()  # 第三种方法在访问父类的方法
22         super(Student,self).eat()  # 第二种方法在访问父类的方法
23         print('%s吃更好的东西'%self.name)
24
25 s1 = Student('sxc',18,188)
26 s1.eat()

 1 # 继承中初始化方法必须调用super
 2 class Person:
 3     def __init__(self,name,age):
 4         self.name = name
 5         self.age = age
 6
 7 class Student(Person):
 8     def __init__(self,name,age,id):  # 当子类需要增加属性时,需要再初始化一次,这时会覆盖父类的初始化方法
 9         super().__init__(name,age)  # 子类初始化方法必须加super,这样就能导入父类的初始化方法
10         self.id = id  # 增加了id属性,原属性也能访问
11
12     def say(self):
13         print('%s说我真帅'%self.name)  # 如果不初始化方法不调用super,self.name就找不到,会报错
14
15 s1 = Student('sxc',18,1414)
16 s1.say()

 1 # 实现一个可以限制元素类型的容器 (字典,列表,元组,集合,字符串)
 2 class Newlist(list):
 3     def __init__(self,kind):
 4         super().__init__()  # 调用父类的初始化方法
 5         self.kind = kind
 6
 7     def append(self,obj):
 8         if type(obj) == self.kind:
 9             super().append(obj)  # 调用父类的append方法
10             print('加入成功')
11         else:
12             print('类型错误')
13
14 n = Newlist(int)  # 定义数据类型为int
15 n.append(123543)
16 print(n)

 1 # 组合:一个类作为另一个类的属性,两者没有关联
 2 # 定义一个英雄类
 3 class Hero:
 4     def __init__(self,name,ad,hp,weapon):
 5         self.name = name
 6         self.ad = ad
 7         self.hp = hp
 8         self.weapon = weapon  # 英雄类和武器类没有关联,想要英雄类使用武器类,必须在初始化时就增加一个武器的属性
 9     # def attack(self,enemy):
10     #     enemy.hp -= self.ad
11     #     print('%s攻击了%s,掉了%s血,血量还剩%s'%(self.name,enemy.name,self.ad,enemy.hp))
12
13 # 定义一个武器类
14 class Weapon:
15     def __init__(self,name,att):
16         self.name = name
17         self.att = att
18
19     def weapon(self,hero,enemy):
20         enemy.hp -= self.att
21         print('%s使用了%s攻击了%s,掉了%s血,血量还剩%s' % (hero.name,self.name,enemy.name, self.att, enemy.hp))
22
23 w1 = Weapon('无尽之刃',100)  # 定义一把武器
24 h1 = Hero('亚索',50,500,w1)  # 定义一个攻击者
25 h2 = Hero('提莫',20,400,w1)  # 定义一个敌人
26
27 h1.weapon.weapon(h1,h2)  # 英雄用武器攻击了另一个英雄

 1 # 定义类
 2 class A:
 3     pass
 4
 5 class B:
 6     pass
 7
 8 class C(A):
 9     pass
10
11 class D(A):
12     pass
13
14 class E(B):
15     pass
16
17 class F(C):
18     pass
19
20 class G(D):
21     pass
22
23 class H(E,F,G):
24     pass
25
26 print(H.mro())