一、组合概念
一个类的对象作为另外一个类对象的属性
第一个例子：
class Weapon:
def prick(self, obj): # 这是该装备的主动技能,扎死对方
obj.life_value -= 500 # 假设攻击力是500
class Person: # 定义一个人类
role = 'person' # 人的角色属性都是人
def __init__(self, name):
self.name = name # 每一个角色都有自己的昵称;
self.weapon = Weapon() # 给角色绑定一个武器;
egg = Person('egon')
egg.weapon.prick()
#egg组合了一个武器的对象，可以直接egg.weapon来使用组合类中的所有方法
第二个例子计算圆环的面积
from math import pi
class Circle:
def __init__(self,r):
self.r = r
def area(self):
return pi * self.r ** 2 #求园的面积
def perimeter(self):
return self.r *pi * 2 #求园的周长
class Ring:
def __init__(self,outside_r,inside_r):
self.out_circle = Circle(outside_r)
self.in_circle = Circle(inside_r)
def area(self):
return self.out_circle.area() - self.in_circle.area() #外环面积-内环面积
def perimeter(self):
return self.out_circle.perimeter() + self.in_circle.perimeter()
r = Ring(10,5) #外环的半径和内环的半径
print(r.area())
print(r.perimeter())
二、继承
继承是一种创建新类的方式，在python中，新建的类可以继承一个或多个父类，父类又可称为基类或超类，新建的类称为派生类或子类
例子： 人狗大战
class Animal: #父类
def __init__(self,name,dps,hp):
self.name=name
self.dps=dps
self.hp=hp
def eat(self):
print('%s吃药,回血了'%(self.name))
class Person(Animal):#子类
def __init__(self,name,dps,hp,sex):
super().__init__(name,dps,hp) #第二中写法 Animal.__init__(self,name,dps,hp)
self.sex=sex
def attack(self,dog):
dog.hp -= self.dps
print('%s打了%s,%s掉了%s点血，%s还剩%s点血'%(self.name,dog.name,dog.name,self.dps,dog.name,dog.hp))
class Dog(Animal):#子类
def __init__(self,name,dps,hp,kind):
super().__init__(name,dps,hp)
self.kind=kind
def bite(self,person):
person.hp -= self.dps
print('%s咬了%s,%s掉了%s点血，%s还剩%s点血' % (self.name, person.name, person.name, self.dps, person.name, person.hp))
alex=Person('alex',5,250,'男')
ha2=Dog('小黑',200,2000,'藏獒')
print(alex.__dict__)
print(ha2.__dict__)
alex.attack(ha2)
ha2.bite(alex)
ha2.eat()
例子2
class Foo:
def __init__(self):
self.func()
def func(self):
print('in Foo')
class Son(Foo):
def func(self):
print('in Son')
Son()
#打印结果是in son
实例化了一个对象，找自己方法里面的self，然后再去执行父类里面的self也就是son里面是self，然后又去调用func,所以打印in son
三、多继承
python两种类
- 经典类 py3已经灭绝了 在python2里还存在，在py2中只要程序员不主动继承object，这个类就是经典类 —— 深度优先
- 新式类 python3所有的类都
钻石继承
class A:
def f(self):
print('in A')
class B(A):
def f(self):
print('in B')
super().f()
class C(A):
pass
def f(self):
print('in C')
super().f()
class D(B,C):
def f(self):
print('in D')
super().f()
d = D()
d.f()
print(D.mro()) #可以查看继承的顺序
#学习中遇到问题没人解答？小编创建了一个Python学习交流群：725638078
#打印结果
in D
in B
in C
in A
[<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>]
super和找父类这件事是两回事
- 在单继承中 super就是找父类
- 在多级承中 super的轨迹 是根据整个模型的起始点而展开的一个广度优先顺序 遵循mro规则
例子2
class A:
def f(self):
print('in A')
class B(A):
pass
# def f(self):
# print('in B')
class C(A):
pass
# def f(self):
# print('in C')
class D(B,C):
pass
# def f(self):
# print('in D')
class E(C):
pass
# def f(self):
# print('in B')
class F(D,E):
pass
# def f(self):
# print('in C')
# d = D()
# d.f()
print(F.mro())