0412 面向对象的组合继承

一、组合

一个类的对象作为另一个类对象的属性
表示的 一种 什么有什么的关系

人狗大战升级版（还未完善）

class Person:
    def __init__(self,name,age,hp,ad):
        self.name = name
        self.hp = hp
        self.name = name
        self.ad = ad
        self.money = 0
    def attack(self,dog):
        dog.hp -= self.ad
        print('%s攻击了%s,%s掉了%s点血' % (self.name,dog.name,dog.name,self.ad))
    def pay(self):
        money = int(input('请输入要充值的金额'))
        self.money += money
        print('您的余额还剩%s' % self.money)
    def wear(self,weapon):
        if self.money >= weapon.price:
            self.weapon = weapon
            self.money -= weapon.price
            print('购买成功，%s装备了%s' % (self.name,weapon.name))
        else:
            print('余额不足，请充值')
    def gunk(self):
        if 'weapon' in alex.__dict__:
            alex.wear(knife)
            print('我要让我的名字响彻天堂')
        else:
            print('请先装备武器')

class Dog:
    def __init__(self,name,kind,hp,ad):
        self.name = name
        self.kind = kind
        self.hp = hp
        self.ad = ad
    def bite(self,person):
        person.hp -= self.ad
        print('%s被雪走砍中了，奄奄一息' % person.name)
class Weapon:
    def __init__(self,name,price,ad,level):
        self.name = name
        self.price = price
        self.level = level
        self.ad = ad * self.level
    def skill(self,dog):
        dog.hp -= self.ad
        print('%s受到了%s的伤害，%s掉了%s点血' % (dog.name,self.name,dog.name,self.ad))

20)
knife = Weapon('雪走',50,60,1)

li=['攻击','充值','装备武器','使用武器攻击']
while True:
    for index,value in enumerate(li,1):
        print(index,value)
    num = int( input('请输入序号'))
    if num == 1:
        alex.attack(egg)
    elif num == 2:
        alex.pay()
    elif num == 3:
        alex.wear(knife)
    elif num == 4:
        alex.gunk()
    else:
        print('请输入正确的序号')

圆形类
写一个圆环类 组合 圆形类 去完成 计算圆环的面积和周长
一个类的对象作为另一个类对象的属性
圆环中有圆

圆形类 ： 计算圆形面积 和 周长
圆环类 :
    圆环的周长 ： 大圆周长加小圆周长
    圆环的面积 :  大圆的面积 - 小圆的面积

from math import pi
class Circle:
    def __init__(self,r):
        self.r = r
    def cal_area(self):
        return pi*self.r**2
    def cal_perimeter(self):
        return 2*pi*self.r


class Ring:   圆环
    def __init__(self,out_r,in_r):
        self.out_circle = Circle(out_r)  将 Circle(out_r)实例化为 self.out_circle
        self.in_circle = Circle(in_r)
    def cal_area(self):
        return self.out_circle.cal_area() - self.in_circle.cal_area()
    def cal_perimeter(self):
        return self.out_circle.cal_perimeter() + self.in_circle.cal_perimeter()

老师
姓名 年龄 性别 班级 ： s11

班级
班级名 班级人数 科目 性质
class Cla:
    def __init__(self,name,num,course,type):
        self.name = name
        self.num = num
        self.course = course
        self.type = type
class Teacher:
    def __init__(self,name,sex,age,a):
        self.name = name
        self.sex = sex
        self.age = age
        self.cla = a
a = Cla('py11',99,'python','全栈脱产')
b = Teacher('太白','男',54,a)
print(b.name)
print(b.cla.num)
print(b.cla.type)

面向对象小结

二、继承

 继承是一种创建新类的方式，在python中，新建的类可以继承一个或多个父类，父类又可称为基类或超类，新建的类称为派生类或子类

 类与类之间的关系： 什么是什么的关系
单继承
class Parent:pass
class Son(Parent):pass # 继承关系
# Son继承了Parent
print(Son.__bases__) # 内置的属性
print(Parent.__bases__) # 内置的属性

在python3中，所有的类都会默认继承object类
继承了object类的所有类都是新式类
如果一个类没有继承任何父类，那么__bases__属性就会显示<class 'object'>

多继承
class Parent1:pass
class Parent2(Parent1):pass
class Parent3:pass
class Son(Parent2,Parent3):pass # 继承关系
print(Parent2.__bases__)
print(Son.__bases__)

class Animal:
    role = 'animal'
    # 先有了人 ,狗两个类,发现两个类有相同的属性、方法  抽象出一个animal类型
    def __init__(self, name,  hp, ad):
        self.name = name
        self.hp = hp
        self.ad = ad
    def eat(self):
        print('%s吃了回血药' % self.name)
class Person(Animal):
    role = 'person'
    def attack(self,dog):   # 派生方法
        print('%s攻击了%s' % (self.name,dog.name))
    def eat2(self):
        print('执行了Person类的eat方法')
class Dog(Animal):
    role = 'dog'
    def bite(self,person):  #派生方法
        print('%s咬了%s' % (self.name,person.name))

alex = Person('alex',10,5)

dog = Dog('teddy',100,20) 

继承中的init
print(Person.__dict__)    {'__module__': '__main__', 'role': 'person', 'attack': <function Person.attack at 0x01E3A6A8>, 'eat2': <function Person.eat2 at 0x01E3A660>, '__doc__': None}
print(Person.role)       # role person
print(alex.__dict__)  {'name': 'alex', 'hp': 10, 'ad': 5}

print(dog)              <__main__.Dog object at 0x01E2BE50>
print(dog.__dict__)   {'name': 'teddy', 'hp': 100, 'ad': 20}

继承中的派生方法

alex.attack(dog)      alex攻击了teddy
dog.bite(alex)        teddy咬了alex
alex.attack(dog)      alex攻击了teddy
dog.bite(alex)        teddy咬了alex

继承父类的方法：自己没有同名方法
alex.eat2()   执行了Person类的eat方法
alex.eat()    alex吃了回血药
dog.eat()     teddy吃了回血药

对象使用名字的顺序: 先找对象自己内存空间中的，再找对象自己类中的，再找父类中的
self.名字的时候，不要看self当前在哪个类里，要看这个self到底是谁的对象

面试题

class Parent:
    def func(self):
        print('in parent func')
    def __init__(self):
        self.func()

class Son(Parent):
    def func(self):
        print('in son func')

s = Son()

#'in son func'