复习
上节课复习 今日内容： 1、如何为对象定制独有的特征，__init__方法 2、属性查找 3、绑定方法 总结 4、面向对象三大特性之一：继承与派生 ''' 面向过程编程： 核心是过程二字，过程指的是解决问题的步骤，即想干什么再干什么后干什么。。。 基于该思想编写程序就好比在设计一条流水线，是一种机械式的思维方式 优点: 复杂的问题流程化、进而简单化 缺点： 可扩展性差 面向对象编程： 核心是对象二字，对象是特征与技能的结合体 基于该思想在编写程序就好比在创造一个世界，世界万物都是对象，你就是这个世界的上帝 对象是特征与技能的结合体,类就是一系列对象相似的特征与技能的结合体 站在不同的角度，总结出的类是截然不同的 在现实世界中一定是先有的一个个具体存在的对象，然后随着人类文明地发展而总结出了不同的类 在程序中务必保证先定义类，后调用类来产生对象 现实世界中总结对象-----》抽取相似之处，得到现实世界中的类---》定义为程序中的类-----》调用类，产生程序中的对象 站在老男孩选课系统的角度： 现实世界中的老男孩学生对象： 对象1： 特征： 学校='oldboy' 姓名='耗哥' 年龄=18 性别='male' 技能： 选课 对象2： 特征： 学校='oldboy' 姓名='猪哥' 年龄=17 性别='male' 技能： 选课 对象3： 特征： 学校='oldboy' 姓名='帅翔' 年龄=19 性别='female' 技能： 选课 站在老男孩选课系统的角度，先总结现实世界中的老男孩学生类 老男孩学生类： 相似的特征： 学校='oldboy' 相似的技能 选课 ''' #1、先定义类 class OldboyStudent: school='oldboy' def choose_course(self): print('is choosing course') #强调：类定义阶段会立刻执行类体代码，会产生类的名称空间，将类体代码执行过程中产生的名字都丢进去 # print(OldboyStudent.__dict__) # 类本质就是一个名称空间/容器，从类的名称空间中增/删/改/查名字 # python为我们提供专门访问属性（名称空间中的名字）的语法，点后的都是属性 # OldboyStudent.school #OldboyStudent.__dict__['school'] # OldboyStudent.x=1 #OldboyStudent.__dict__['x']=1 # OldboyStudent.school='Oldboy' #OldboyStudent.__dict__['school']='Oldboy' # del OldboyStudent.x #del OldboyStudent.__dict__['x'] # 类中定义的函数是类的函数属性，类可以使用，但使用的就是一个普通的函数而已，意味着需要完全遵循函数的参数规则，该传几个值就传几个 # OldboyStudent.choose_course(123) #2、后调用类产生对象，调用类的过程称之为实例化，实例化的结果称为类的一个实例或者对象 stu1=OldboyStudent() stu2=OldboyStudent() stu3=OldboyStudent() # print(stu1) # print(stu2) # print(stu3) # print(OldboyStudent.school) # OldboyStudent.school='OLDBOY' # print(stu1.school) # print(stu2.school) # print(stu3.school)
为对象定制自己独有的属性
''' # 例1 class OldboyStudent: school='oldboy' def choose_course(self): print('is choosing course') stu1=OldboyStudent() stu2=OldboyStudent() stu3=OldboyStudent() #对象本质也就是一个名称空间而已，对象名称空间是用存放对象自己独有的名字/属性，而 #类中存放的是对象们共有的属性 # print(stu1.__dict__) # print(stu2.__dict__) # print(stu3.__dict__) stu1.name='耗哥' stu1.age=18 stu1.sex='male' # print(stu1.name,stu1.age,stu1.sex) # print(stu1.__dict__) stu2.name='猪哥' stu2.age=17 stu2.sex='male' stu3.name='帅翔' stu3.age=19 stu3.sex='female' # 例2 class OldboyStudent: school='oldboy' def choose_course(self): print('is choosing course') stu1=OldboyStudent() stu2=OldboyStudent() stu3=OldboyStudent() def init(obj,x,y,z): obj.name=x obj.age=y obj.sex=z # stu1.name='耗哥' # stu1.age=18 # stu1.sex='male' init(stu1,'耗哥',18,'male') # stu2.name='猪哥' # stu2.age=17 # stu2.sex='male' init(stu2,'诸哥',17,'male') # stu3.name='帅翔' # stu3.age=19 # stu3.sex='female' init(stu3,'帅翔',19,'female') print(stu1.__dict__) print(stu2.__dict__) print(stu3.__dict__) ''' class OldboyStudent: school='oldboy' def __init__(obj, x, y, z): #会在调用类时自动触发 obj.name = x #stu1.name='耗哥' obj.age = y #stu1.age=18 obj.sex = z #stu1.sex='male' def choose_course(self): print('is choosing course') #调用类时发生两件事 #1、创造一个空对象stu1 #2、自动触发类中__init__功能的执行，将stu1以及调用类括号内的参数一同传入 stu1=OldboyStudent('耗哥',18,'male') #OldboyStudent.__init__(stu1,'耗哥',18,'male') stu2=OldboyStudent('猪哥',17,'male') stu3=OldboyStudent('帅翔',19,'female') print(stu1.__dict__) print(stu2.__dict__) print(stu3.__dict__)
属性查找
class OldboyStudent: school='oldboy' count=0 def __init__(self, x, y, z): #会在调用类时自动触发 self.name = x #stu1.name='耗哥' self.age = y #stu1.age=18 self.sex = z #stu1.sex='male' OldboyStudent.count+=1 def choose_course(self): print('is choosing course') # 先从对象自己的名称空间找，没有则去类中找，如果类也没有则报错 stu1=OldboyStudent('耗哥',18,'male') stu2=OldboyStudent('猪哥',17,'male') stu3=OldboyStudent('帅翔',19,'female') # print(OldboyStudent.count) print(stu1.count) print(stu2.count) print(stu3.count)
绑定方法
class OldboyStudent: school='oldboy' def __init__(self, x, y, z): #会在调用类时自动触发 self.name = x #stu1.name='耗哥' self.age = y #stu1.age=18 self.sex = z #stu1.sex='male' def choose_course(self,x): print('%s is choosing course' %self.name) def func(): pass # 类名称空间中定义的数据属性和函数属性都是共享给所有对象用的 # 对象名称空间中定义的只有数据属性，而且时对象所独有的数据属性 stu1=OldboyStudent('耗哥',18,'male') stu2=OldboyStudent('猪哥',17,'male') stu3=OldboyStudent('帅翔',19,'female') # print(stu1.name) # print(stu1.school) # 类中定义的函数是类的函数属性，类可以使用，但使用的就是一个普通的函数而已，意味着需要完全遵循函数的参数规则，该传几个值就传几个 # print(OldboyStudent.choose_course) # OldboyStudent.choose_course(123) # 类中定义的函数是共享给所有对象的，对象也可以使用，而且是绑定给对象用的， #绑定的效果：绑定给谁，就应该由谁来调用，谁来调用就会将谁当作第一个参数自动传入 # print(id(stu1.choose_course)) # print(id(stu2.choose_course)) # print(id(stu3.choose_course)) # print(id(OldboyStudent.choose_course)) # print(id(stu1.school)) # print(id(stu2.school)) # print(id(stu3.school)) # # print(id(stu1.name),id(stu2.name),id(stu3.name)) # stu1.choose_course(1) # stu2.choose_course(2) # stu3.choose_course(3) # stu1.func() # 补充：类中定义的函数，类确实可以使用，但其实类定义的函数大多情况下都是绑定给对象用的，所以在类中定义的函数都应该自带一个参数self
类即类型
#在python3中统一了类与类型的概念，类就是类型 class OldboyStudent: school='oldboy' def __init__(self, x, y, z): #会在调用类时自动触发 self.name = x #stu1.name='耗哥' self.age = y #stu1.age=18 self.sex = z #stu1.sex='male' def choose_course(self,x): print('%s is choosing course' %self.name) stu1=OldboyStudent('耗哥',18,'male') # stu1.choose_course(1) #OldboyStudent.choose_course(stu1,1) # OldboyStudent.choose_course(stu1,1) l=[1,2,3] #l=list([1,2,3]) # print(type(l)) # l.append(4) #list.append(l,4) list.append(l,4) print(l)
小结
''' # 对象是一个高度整合的产物，整合数据与专门操作该数据的方法（绑定方法） class Foo: def __init__(self,host,port,db,chartset): self.host=host self.port=port self.db=db self.charset=charset def exc1(self,sql): conn = connect(self.host, self.port, self.db, self.charset) conn.execute(sql) return xxx def exc2(self,proc_name) conn = connect(self.host, self.port, self.db, self.charsett) conn.call_proc(sql) return xxx class Bar: def __init__(self,x,y,z,a,b,c): self.x=x self.y=y self.z=z self.a=a self.b=b self.c=c def exc3(self,xxx): pass def exc4(self,yyy) pass obj1=Foo('1.1.1.1',3306,'db1','utf-8') obj1.exc1('select * from t1') obj1.exc1('select * from t2') obj1.exc1('select * from t3') obj1.exc1('select * from t4') obj2=Foo('1.1.1.2',3306,'db1','utf-8') obj2.exc1('select * from t4') '''
继承与派生
''' 1、什么是继承 继承是一种新建类的方式，新建的类称为子类，被继承的类称为父类 继承的特性是：子类会遗传父类的属性 强调：继承是类与类之间的关系 2、为什么用继承 继承的好处就是可以减少代码的冗余 3、如何用继承 在python中支持一个类同时继承多个父类 在python3中 如果一个类没有继承任何类，那默认继承object类 在python2中： 如果一个类没有继承任何类，不会继承object类 新式类 但凡继承了object的类以及该类的子类，都是新式类 经典类 没有继承object的类以及该类的子类，都是经典类 在python3中都是新式类，只有在python2中才区别新式类与经典类 新式类vs经典类? ''' class Parent1(object): pass class Parent2(object): pass class Sub1(Parent1,Parent2): pass # print(Sub1.__bases__) print(Parent1.__bases__) print(Parent2.__bases__)
继承的应用
#派生：子类中新定义的属性，子类在使用时始终以自己的为准 class OldboyPeople: school = 'oldboy' def __init__(self,name,age,sex): self.name = name #tea1.name='egon' self.age = age #tea1.age=18 self.sex = sex #tea1.sex='male' class OldboyStudent(OldboyPeople): def choose_course(self): print('%s is choosing course' %self.name) class OldboyTeacher(OldboyPeople): # tea1,'egon',18,'male',10 def __init__(self,name,age,sex,level): # self.name=name # self.age=age # self.sex=sex OldboyPeople.__init__(self,name,age,sex) self.level=level def score(self,stu_obj,num): print('%s is scoring' %self.name) stu_obj.score=num stu1=OldboyStudent('耗哥',18,'male') tea1=OldboyTeacher('egon',18,'male',10) #对象查找属性的顺序：对象自己-》对象的类-》父类-》父类。。。 # print(stu1.school) # print(tea1.school) # print(stu1.__dict__) # print(tea1.__dict__) tea1.score(stu1,99) print(stu1.__dict__) # 在子类派生出的新功能中重用父类功能的方式有两种： #1、指名道姓访问某一个类的函数：该方式与继承无关 # class Foo: # def f1(self): # print('Foo.f1') # # def f2(self): # print('Foo.f2') # self.f1() # # class Bar(Foo): # def f1(self): # print('Bar.f1') # # #对象查找属性的顺序：对象自己-》对象的类-》父类-》父类。。。 # obj=Bar() # obj.f2() # ''' # Foo.f2 # Bar.f1 # '''
明日内容：1、继承剩余知识 2、封装 3、多态
面向对象作业 1、类的属性和对象的属性有什么区别? 2、面向过程编程与面向对象编程的区别与应用场景? 3、类和对象在内存中是如何保存的。 4、什么是绑定到对象的方法，、如何定义，如何调用，给谁用？有什么特性 5、如下示例, 请用面向对象的形式优化以下代码 在没有学习类这个概念时，数据与功能是分离的,如下 def exc1(host,port,db,charset): conn=connect(host,port,db,charset) conn.execute(sql) return xxx def exc2(host,port,db,charset,proc_name) conn=connect(host,port,db,charset) conn.call_proc(sql) return xxx # 每次调用都需要重复传入一堆参数 exc1('127.0.0.1',3306,'db1','utf8','select * from tb1;') exc2('127.0.0.1',3306,'db1','utf8','存储过程的名字') 6、下面这段代码的输出结果将是什么？请解释。 class Parent(object): x = 1 class Child1(Parent): pass class Child2(Parent): pass print(Parent.x, Child1.x, Child2.x) Child1.x = 2 print(Parent.x, Child1.x, Child2.x) Parent.x = 3 print(Parent.x, Child1.x, Child2.x) 7、定义学校类，实例化出：北京校区、上海校区两个对象 校区独有的特征有： 校区名=“xxx” 校区地址={'city':"所在市",'district':'所在的区'} 多们课程名=['xxx','yyy','zzz'] 多个班级名=['xxx','yyy','zzz'] 校区可以： 1、创建班级 2、查看本校区开设的所有班级名 3、创建课程 4、查看本校区开设的所有课程名 8、定义出班级类，实例化出两个班级对象 班级对象独有的特征： 班级名=‘xxx’ 所属校区名=‘xxx’ 多门课程名=['xxx','yyy','zzz'] 多个讲师名=['xxx','xxx','xxx'] 班级可以： 1、查看本班所有的课程 2、查看本班的任课老师姓名 9、定义课程类，实例化出python、linux、go三门课程对象 课程对象独有的特征： 课程名=‘xxx’ 周期=‘3mons’ 价格=3000 课程对象可以： 1、查看课程的详细信息 10、定义学生类，实例化出张铁蛋、王三炮两名学生对象 学生对象独有的特征： 学号=10 名字=”xxx“ 班级名=['xxx','yyy'] 分数=33 学生可以： 1、选择班级 3、注册，将对象序列化到文件 11、定义讲师类，实例化出egon，lqz，alex，wxx四名老师对象 老师对象独有的特征： 名字=“xxx” 等级=“xxx”、 老师可以： 1、修改学生的成绩 12、用面向对象的形式编写一个老师类, 老师有特征：编号、姓名、性别、年龄、等级、工资，老师类中有功能 1、生成老师唯一编号的功能，可以用hashlib对当前时间加上老师的所有信息进行校验得到一个hash值来作为老师的编号 def create_id(self): pass 2、获取老师所有信息 def tell_info(self): pass 3、将老师对象序列化保存到文件里，文件名即老师的编号，提示功能如下 def save(self): with open('老师的编号','wb') as f: pickle.dump(self,f) 4、从文件夹中取出存储老师对象的文件，然后反序列化出老师对象,提示功能如下 def get_obj_by_id(self,id): return pickle.load(open(id,'rb')) 13、按照定义老师的方式，再定义一个学生类 14、抽象老师类与学生类得到父类，用继承的方式减少代码冗余 15、基于面向对象设计一个对战游戏并使用继承优化代码，参考博客 http://www.cnblogs.com/linhaifeng/articles/7340497.html#_label1
# class OldboyStudent: # school='oldboy' # count = 0 # # def __init__(self,name,age,sex): # self.count +=1 # self.name=name # self.age=age # self.sex=sex # OldboyStudent.count += 1 # # def learn(self): # print('%s is learning' %self.name) #新增self.name # # def eat(self): # print('%s is eating' %self.name) # # def sleep(self): # print('%s is sleeping' %self.name) # # s1=OldboyStudent('李坦克','男',18) # print(s1.count) # s2=OldboyStudent('王大炮','女',38) # print(s2.count) # s3=OldboyStudent('牛榴弹','男',78) # print(s3.count) # # class Parent1(object): # pass # # class Parent2(object): # pass # # class Sub1(Parent1,Parent2): # pass # # print(Sub1.__bases__) # print(Parent1.__bases__) # print(Parent2.__bases__) # # class Parent(object): # x = 1 # # # class Child1(Parent): # pass # # # class Child2(Parent): # pass # # # print(Parent.x, Child1.x, Child2.x) # # Child1.x = 2 # print(Parent.x, Child1.x, Child2.x) # # Parent.x = 3 # print(Parent.x, Child1.x, Child2.x) # 7、定义学校类，实例化出：北京校区、上海校区两个对象 # 校区独有的特征有： # 校区名 =“xxx” # 校区地址 = {'city': "所在市", 'district': '所在的区'} # 多们课程名 = ['xxx', 'yyy', 'zzz'] # 多个班级名 = ['xxx', 'yyy', 'zzz'] # # 校区可以： # 1、创建班级 # 2、查看本校区开设的所有班级名 # 3、创建课程 # 4、查看本校区开设的所有课程名 # class school: # def __init__(self,name,addr,courses,classes): # self.name=name # self.addr=addr # self.courses=courses # self.classes=classes # # def create_class(self,addcla): # self.classes.append(addcla) # # def view_class(self): # return self.classes # # def create_course(self,cour): # self.courses.append(cour) # # def view_course(self): # return self.courses # # bj = school('bj',{'city': "bj", 'district': 'bj'},['python','linux'],['py1','py2']) # sh = school('sh',{'city': "sh", 'district': 'sh'},['python','linux'],['py1','py2']) # bj.create_class('py3') # print(bj.view_class()) # bj.create_course('java') # print(bj.view_course()) # 8、定义出班级类，实例化出两个班级对象 # 班级对象独有的特征： # 班级名 =‘xxx’ # 所属校区名 =‘xxx’ # 多门课程名 = ['xxx', 'yyy', 'zzz'] # 多个讲师名 = ['xxx', 'xxx', 'xxx'] # # 班级可以： # 1、查看本班所有的课程 # 2、查看本班的任课老师姓名 # class classes: # def __init__(self,ClaName,SchName,Courses,Teachers): # self.name=ClaName # self.schlool=SchName # self.course=Courses # self.teacher=Teachers # # def view_courses(self): # return self.course # def view_teachers(self): # return self.teacher # # py1 = classes('py1','sh',['python','linux','c'],['egon','lqz','ckq']) # py2 = classes('py2','sh',['python','linux','c'],['egon','lqz','ckq']) # print(py1.view_courses(),py1.view_teachers()) # print(py2.view_courses(),py2.view_teachers()) # 9、定义课程类，实例化出python、linux、go三门课程对象 # 课程对象独有的特征： # 课程名 =‘xxx’ # 周期 =‘3mons’ # 价格 = 3000 # # 课程对象可以： # 1、查看课程的详细信息 # class course: # def __init__(self,curriculum_name,price=3000,period='3mons',): # self.c_name=curriculum_name # self.price=price # self.period=period # def CheckCourse(self): # return '课程名:%s 周期:%s 价格:%s' %(self.c_name,self.period,self.price) # # python = course('python') # linux = course('linux') # go = course('go') # print(python.CheckCourse()) # print(linux.CheckCourse()) # print(go.CheckCourse()) # 10、定义学生类，实例化出张铁蛋、王三炮两名学生对象 # 学生对象独有的特征： # 学号 = 10 # 名字 =”xxx“ # 班级名 = ['xxx', 'yyy'] # 分数 = 33 # # 学生可以： # 1、选择班级 # 3、注册，将对象序列化到文件 # import json # class students: # def __init__(self,name,cla_name,score=33,stu_num=10): # self.stu_num=stu_num # self.name=name # self.cla_name=cla_name # self.score=score # def choice_class(self,cho_cla): # self.chocla=cho_cla # def register(self): # user_dic = {'学号':self.stu_num,'姓名':self.name,'班级名':self.cla_name,'分数':self.score,'选择班级':self.chocla} # user_path = '%s.json' %self.name # with open(user_path,'w',encoding='utf-8') as f: # json.dump(user_dic,f) # f.flush() # stu1 = students('张铁蛋',['python1','linux1']) # stu2 = students('王三炮',['python2','linux2']) # stu1.choice_class('python') # stu2.choice_class('linux') # stu1.register() # stu2.register() # 11、定义讲师类，实例化出egon，lqz，alex，wxx四名老师对象 # 老师对象独有的特征： # 名字 =“xxx” # 等级 =“xxx”、 # 老师可以： # 1、修改学生的成绩 # class teachers: # def __init__(self,name,level): # self.name=name # self.level=level # def change_score(self,stu,score): # stu.score = score # egon = teachers('egon',10) # lqz = teachers('lqz',10) # alex = teachers('alex',10) # wxx = teachers('wxx',10) # egon.change_score(stu1,40) # print(stu1.score) # import hashlib # import time # import pickle # # # class teachers: # def __init__(self, name, sex, age, level, salary): # self.name = name # self.sex = sex # self.age = age # self.level = level # self.salary = salary # # def create_id(self): # m = hashlib.md5() # join = str(time.time()) + self.name + self.sex + str(self.age) + str(self.level) + str(self.salary) # m.update(join.encode('utf-8')) # self.number = m.hexdigest() # # def tell_info(self): # return '编号:%s 姓名:%s 性别:%s 年龄:%s 等级:%s工资:%s' % ( # self.number, self.name, self.sex, self.age, self.level, self.salary) # # def save(self): # # db_tea = self.number # tea_dic = {'编号': self.number, '姓名': self.name, '性别': self.sex, '年龄': self.age, '等级': self.level, # '工资': self.salary} # with open(self.number, 'wb') as f: # pickle.dump(tea_dic, f) # f.flush() # # def get_obj_by_id(self, id): # with open(id,'rb') as f: # return pickle.load(f) # egon = teachers('egon','male',18,10,100) # egon.create_id() # print(egon.tell_info()) # egon.save() # print(egon.get_obj_by_id('29a42b1882e2141049a57f723a75082b')) ##13 # import hashlib # import time # import pickle # class students: # def __init__(self,name,sex,age): # self.name=name # self.sex=sex # self.age=age # # def create_id(self): # m=hashlib.md5() # join = str(time.time())+self.name+self.sex+str(self.age) # m.update(join.encode('utf-8')) # self.number=m.hexdigest() # def tell_info(self): # return '姓名:%s 性别:%s 年龄:%s 学号:%s' %(self.name,self.sex,self.age,self.number) # def save(self): # stu_dic = {'name':self.name,'sex':self.sex,'age':self.age,'number':self.number} # with open(self.number,'wb') as f: # pickle.dump(stu_dic,f) # f.flush() # def get_obj_by_id(self, id): # with open(id,'rb') as f: # return pickle.load(f) # stu1 = students('xjj','male',18) # stu1.create_id() # print(stu1.tell_info()) # stu1.save() # print(stu1.get_obj_by_id('ea1fd3d4cd6b7a119a2e909050c48c40')) # import hashlib # import time # import pickle # # class people: # def __init__(self,name,sex,age): # self.name=name # self.sex=sex # self.age=age # def create_id(self): # join = str(time.time())+self.name+self.sex+str(self.age) # m=hashlib.md5() # m.update(join.encode('utf-8')) # self.number=m.hexdigest() # # class students: # def __init__(self,name,sex,age): # people.__init__(self,name,sex,age) # # # def create_id(self): # m=hashlib.md5() # join = str(time.time())+self.name+self.sex+str(self.age) # m.update(join.encode('utf-8')) # self.number=m.hexdigest() # def tell_info(self): # return '姓名:%s 性别:%s 年龄:%s 学号:%s' %(self.name,self.sex,self.age,self.number) # def save(self): # stu_dic = {'name':self.name,'sex':self.sex,'age':self.age,'number':self.number} # with open(self.number,'wb') as f: # pickle.dump(stu_dic,f) # f.flush() # def get_obj_by_id(self, id): # with open(id,'rb') as f: # return pickle.load(f) # # class teachers: # def __init__(self, name, sex, age, level, salary): # people.__init__(self,name,sex,age) # self.level = level # self.salary = salary # # def create_id(self): # m = hashlib.md5() # join = str(time.time()) + self.name + self.sex + str(self.age) + str(self.level) + str(self.salary) # m.update(join.encode('utf-8')) # self.number = m.hexdigest() # # def tell_info(self): # return '编号:%s 姓名:%s 性别:%s 年龄:%s 等级:%s工资:%s' % ( # self.number, self.name, self.sex, self.age, self.level, self.salary) # # def save(self): # # db_tea = self.number # tea_dic = {'编号': self.number, '姓名': self.name, '性别': self.sex, '年龄': self.age, '等级': self.level, # '工资': self.salary} # with open(self.number, 'wb') as f: # pickle.dump(tea_dic, f) # f.flush() # # def get_obj_by_id(self, id): # with open(id,'rb') as f: # return pickle.load(f) class Riven: camp = 'Noxus' def __init__(self, nickname, aggressivity=54, life_value=414, money=1001, armor=3): self.nickname = nickname self.aggressivity = aggressivity self.life_value = life_value self.money = money self.armor = armor def attack(self, enemy): damage_value = self.aggressivity - enemy.armor enemy.life_value -= damage_value class Garen: camp = 'Demacia' def __init__(self, nickname, aggressivity=58, life_value=455, money=100, armor=10): self.nickname = nickname self.aggressivity = aggressivity self.life_value = life_value self.money = money self.armor = armor def attack(self, enemy): damage_value = self.aggressivity - enemy.armor enemy.life_value -= damage_value class BlackCleaver: def __init__(self, price=475, aggrev=9, life_value=100): self.price = price self.aggrev = aggrev self.life_value = life_value def update(self, obj): obj.money -= self.price # 减钱 obj.aggressivity += self.aggrev # 加攻击 obj.life_value += self.life_value # 加生命值 def fire(self, obj): # 这是该装备的主动技能,喷火,烧死对方 obj.life_value -= 1000 # 假设火烧的攻击力是1000 r1=Riven('草丛伦') g1=Garen('盖文') b1=BlackCleaver() print(r1.aggressivity,r1.life_value,r1.money) if r1.money > b1.price: r1.b1=b1 #组合 b1.update(r1) print(r1.aggressivity,r1.life_value,r1.money) #r1的攻击力,生命值,护甲 print(g1.life_value) r1.attack(g1) #普通攻击 print(g1.life_value) r1.b1.fire(g1) #用装备攻击 print(g1.life_value) #g1的生命值小于0就死了