day 19 类之间的组合

类组合：

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

# 人狗大战
class Person:
    def __init__(self,name,sex,hp,ad):
        self.name = name     # 对象属性 属性
        self.sex = sex
        self.hp = hp         #血量
        self.ad = ad         #攻击力
        self.money = 0
    def attack(self,d):
        d.hp -= self.ad
        print('%s攻击了%s，%s掉了%s点血'%(self.name,d.name,d.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'%weapon.name)
        else:
            print('余额不足，请充值。')
    def attack_with_weapon(self,dog):
        if 'weapon' in self.__dict__:
            self.weapon.skill(dog)
        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,p):
        p.hp -= self.ad
        print('%s咬了%s一口,%s掉了%s点血' % (self.name, p.name, p.name, self.ad))

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))

# 武器 是人的一个属性
# 武器也是一个类
    # 攻击力 价格 名字 品级
    # 技能 : 方法

# alex = Person('a_sb','不详',1,5)
# boss_jin = Person('金老板','女',20,50)
# teddy = Dog('笨笨','teddy',150,50)
# futou = Weapon('斧f头',1000,100,1)
# nife = Weapon('刀',1000,100,1)

# alex.weapon = '123'
# alex.b1 = nife
# alex.b2 = futou
# print(alex.__dict__)
# alex.b.skill()
#为什么会用组合 ：独立的对象不能发挥他的作用，必须依赖一个对象

# alex.pay()
# alex.wear(futou)
# print(alex.__dict__)
# print(alex.weapon)
# print(futou)
# # print(alex.weapon is futou)
# futou.skill(teddy)
# alex.weapon.skill(teddy)

#武器 装备
lst = ['攻击','充值','装备武器','使用武器攻击']
while True:
    for index, value in enumerate(lst, 1):
        print(index, value)
    num = int(input('请选择操作序号 >>>'))
    if num == 1:
        alex.attack(teddy)
    elif num == 2:
        alex.pay()
    elif num == 3:
        print('装备前余额 %s'%alex.money)
        alex.wear(futou)
        print('装备后余额 %s' % alex.money)
    elif num == 4:
        alex.attack_with_weapon(alex)
    else:
        print('无效的序号')






组合实例：
　　

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

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

# class Ring1:
#     def __init__(self,out_r,in_r):
#         self.out_r = out_r
#         self.in_r = in_r
#     def cal_area(self):
#         return abs(pi*self.out_r**2 - pi*self.in_r**2)
#     def cal_perimeter(self):
#         return pi * self.out_r * 2 + pi * self.in_r * 2

# 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 pi * self.r * 2

#
# class Ring2:  # 圆环
#     def __init__(self,out_r,in_r):
#         c1_obj = Circle(out_r)
#         self.out_circle = c1_obj
#         self.in_circle = Circle(in_r)
#     def 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()
#
#
# r1 = Ring2(10,5)
# print(r1.area())
# print(r1.cal_perimeter())

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

# 班级
# 班级名 班级人数 科目 性质

class Clas:
    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,py11):
        self.name = name
        self.sex = sex
        self.age = age
        self.cls = py11

py11 = Clas('超级无敌s11',89,'python','脱产全栈')
print(py11.course)

boss_jin = Teacher('太白','？',40,py11)
print(py11.course)          # 11期的课程
print(boss_jin.cls.course)  # 金老板所带的班级的课程
print(boss_jin.cls.name)  # 金老板所带的班级的课程
print(boss_jin.cls.num)  # 金老板所带的班级的课程

初始继承：

# 面向对象的三大特性
    # 继承  1.8天
    # 多态  0.2天
    # 封装  1天

# 初识继承

# 游戏
# 人物 ： 名字 角色 性别 职业 技能
#     治疗 # 回血 增加属性
#         医生
#         护士
#     输出
#     防御

# class Person:
#     def __init__(self,name,hp,ad):
#         self.name = name     # 对象属性 属性
#         self.hp = hp         #血量
#         self.ad = ad         #攻击力
#
# class Dog:
#     def __init__(self,name,hp,ad):
#         self.name = name
#         self.hp = hp
#         self.ad = ad

# 类与类之间的关系： 什么是什么的关系
# 单继承
# 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'
    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):
        r = 'Person'

        def attack(self, dog):  # 派生方法
            print("%s攻击了%s" % (self.name, dog.name))
    def eat2(self):
        print('执行了Person类的eat方法')
        self.money = 100
        self.money -= 10
        self.hp += 10

class Dog(Animal):
    def bite(self,person):  # 派生方法
        print("%s咬了%s" % (self.name, person.name))

# 先有了人 狗两个类
# 发现两个类有相同的属性、方法
# 人和狗 都是游戏里的角色
# 抽象出一个animal类型
# 继承

# 继承中的init
# alex = Person('alex',10,5)
# print(Person.__dict__)   # role
# print(Person.role)
# print(alex.__dict__)
# dog = Dog('teddy',100,20)
# print(dog)
# print(dog.__dict__)

# 继承中的派生方法
# alex = Person('alex',10,5)
# dog = Dog('teddy',100,20)
# alex.attack(dog)
# dog.bite(alex)

# 继承父类的方法：自己没有同名方法
# alex = Person('alex',10,5)
# dog = Dog('teddy',100,20)
# alex.eat2()
# alex.eat()
# dog.eat()

# 对象使用名字的顺序: 先找对象自己内存空间中的，再找对象自己类中的，再找父类中的
# alex = Person('alex',10,5)
# alex.eat = 'aaa'
# print(alex.eat())  # 报错

# 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()