类组合：
# 组合 一个类的对象作为另一个类对象的属性
# 表示的 一种 什么有什么的关系
# 人狗大战
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()