Day19

1、组合

组合：一个类的对象作为另一个类对象的属性

表示的一种什么有什么的关系

#人狗大战
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,d):
        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('斧头',1000,100,1)
nife = Weapon('刀',1000,100,1)

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

2、继承

类与类之间的关系： 什么是什么的关系

单继承

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

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

self.名字的时候，不要看self当前在哪个类里，要看这个self到底是谁的对象