一、引例--乌龟吃鱼
利用上一节课我们学到的知识,我们可以写一个简单的乌龟吃鱼的游戏,规则如下:
1、游戏背景为10*10的方格内
2、游戏开始自动生成10条鱼和一只乌龟
3、他们的移动方向是随机的
4、乌龟的最大移动能力是2,上下左右均可移动2格以内
5、鱼的最大移动能力为1,上下左右移动均为1格
6、当乌龟移动到边界时,自动反向移动
7、乌龟的初始体能为100,200为上限;每次移动需要消耗一点体力
8、当乌龟和鱼的坐标重合,代表乌龟把鱼吃掉,并且乌龟体力增加20
9、当乌龟没有体力值或鱼被吃光,则游戏结束
解析:练习上节课我们学习的知识,显然有乌龟和鱼两大类,在这两个类中他们各自有各自的行为(在类中我们也可以叫方法);现在有了最基本的思路,在乌龟的类中,他有----移动、判断是否越界、吃鱼;鱼具有的属性:-----移动,判断是否越界
有了上面的的思路我们就可以上手了。。。。。。
import random class Turtle(object): def __init__(self): self.x = random.randint(1, 9) #划定边界范围为10*10 self.y = random.randint(1, 9) self.power = 100 def move(self): move_skill = [-1, 1, 0, -2, 2] #乌龟的移动能力只有这5中可能, new_x = self.x + random.choice(move_skill) #新的x坐标=最初的+移动的随机值 new_y = self.y + random.choice(move_skill) #y同理 self.x = self.is_vaild(new_x) #判断新的坐标是否合法,在类中调用方法 self.y = self.is_vaild(new_y) self.power -= 1 #每移动一次体力值箭1 def is_vaild(self, point): #判断坐标是否还在边界内,如果超出则需要反转 if point <0: return 0 - point elif point >9: return 9 - (point - 9) return point def eat(self): #每吃掉一条鱼就可以增加20体力,200为上限 self.power += 20 if self.power >=200: self.power = 200 class Fish(object): def __init__(self): self.x = random.randint(1, 9) self.y = random.randint(1, 9) def move(self): move_skill = [-1, 1, 0] new_x = self.x + random.choice(move_skill) new_y = self.y + random.choice(move_skill) self.x = self.is_vaild(new_x) self.y = self.is_vaild(new_y) def is_vaild(self,point): if point <0: return 0 - point elif point >9: return 9 - (point - 9) return point def main(): t1 = Turtle() #把Turtle类实例化 fish = [Fish() for i in range(10)] #产生10条鱼 while True: #游戏的两种种结果:鱼被吃完了、乌龟没有体力值了 if t1.power <= 0: print('乌龟累死了......') break elif len(fish) == 0: print('鱼被吃光,乌龟赢了!!!') break else: t1.move() for fishs in fish: fishs.move() if t1.x == fishs.x and t1.y == fishs.y: t1.eat() fish.remove(fishs) print('鱼被吃掉了.....') print('乌龟的最新体能%s'%(t1.power)) else: print('乌龟没有吃掉鱼,体力值还有:%s'%(t1.power)) if __name__ =="__main__": main()
运行上面的代码我们就能看到电脑自己和自己玩的结果;通过写上面的代码我们不难发现代码很多都是重覆性的,所以我们就要用到下面的内容:继承
二、继承
注意:在python2中既有新式类也有经典类;
1)经典类的继承算法: 深度优先算法
2)新式类的继承算法: 广度优先算法在OOP程序设计中,当我们定义一个class的时候,可以从某个现有的class继承,新的class称为子类(Subclass),而被继承的class称为基类、父类或超类(Base class、Super class)。
比如:我们先写一个Animal类;
class People(object): def run(self): print("People is running...")
当我们需要定义student类和teacher类时,就可以继承People类:
class Student(People): pass class Teacher(People): pass
对于student来说,people就是它的父类,对于people来说, student 就是它的子类。student和teacher类似。
继承有什么好处?最大的好处是子类获得了父类的全部功能。由于 people 实现了run() 方法,因此, student和teacher作为它的子类,什么事也没干,就自动拥有了run()方法:
s1 = Student() t1 = Teacher() s1.run() t1.run()
上面的过程就为 我们很好的演示了继承;我们还可以给子类添加新的方法,即使是与父类的方法相同;
继承的第二个好处需要我们对代码做一点改进。你看到了,无论是student还是teacher ,它们 run()的时候,显示的都是 People is running... ,符合逻辑的做法是分别显示 Student is running... 和 Teacher is running... ,因此,对student还是teacher 类改进如下:
class People(object): def run(self): print("People is running...") class Student(People): def run(self): print("Student is running...") class Teacher(People): def run(self): print("Teacher is running...") s1 = Student() t1 = Teacher() s1.run() t1.run()
继承还可以一级一级地继承下来,就好比从爷爷到爸爸、再到儿子这样的关系。而任何类,最终都可以追溯到根类object,这些继承关系看上去就像一颗倒着的树。比如如下的继承树:
当子类和父类都存在相同的 run() 方法时,我们说,子类的 run() 覆盖了父类的 run() ,在代码运行的时候,总是会调用子类的run()。这样,我们就获得了继承的另一个好处:多态。
三、多态
1、什么是多态
要理解什么是多态,我们首先要对数据类型再作一点说明。当我们定义一个class的时候,我们实际上就定义了一种数据类型。我们定义的数据类型和Python自带的数据类型,比如str、list、dict没什么两样:
a=list() #a是list类型 b=People() #b是Animal类型 c=Student() #c是Dog类型
判断一个变量是否是某个类型可以用 isinstance() 判断:
>>> isinstance(a, list) True >>> isinstance(b, People) True >>> isinstance(c, Student) True
看来a、b、c 确实对应着list 、Animal、Dog 这3种类型。如果我们再试一次:
>>> isinstance(c, People) True
看来c不仅仅是Student,c还是People !
不过仔细想想,这是有道理的,因为Student 是从People 继承下来的,当我们创建了一个Student的实例c 时,我们认为 c的数据类型是 Student没错,但 c 同时也是People 也没错,Student本来就是People的一种!所以,在继承关系中,如果一个实例的数据类型是某个子类,那它的数据类型也可以被看做是父类。但是,反过来就不行;
2、多态的好处
要理解多态的好处,我们还需要再编写一个函数,这个函数接受一个People类型的变量:
def run_anything(people): people.run() people.run()
当我们传入People实例的时候:
以及其他类的实例:
run_anything(People()) run_anything(Student()) run_anything(Teacher())
多态的好处就是,当我们需要传入Student、Teacher ......时,我们只需要接收People类型就可以了,因为Student、Teacher......都是People类型,然后,按照People类型进行操作即可。由于People类型有run()方法,因此,传入的任意类型,只要是People类或者子类,就会自动调用实际类型的run()方法,这就是多态的意思:对于一个变量,我们只需要知道它是People类型,无需确切地知道它的子类型,就可以放心地调用run()方法,而具体调用的run()方法是作用在People 、Student、Teacher 还是其他对象上,由运行时该对象的确切类型决定,这就是多态真正的威力:调用方只管调用,不管细节,而当我们新增一种People的子类时,只要确保run()方法编写正确,不用管原来的代码是如何调用的。
这就是著名的“开闭”原则:
对扩展开放:允许新增People子类;
对修改封闭:不需要修改依赖People类型的run_anything等函数。
四、对示例(乌龟吃鱼)升级
import random class Father(object): def __init__(self): self.x = random.randint(1, 9) self.y = random.randint(1, 9) def is_vaild(self, point): if point <0: return 0 - point elif point >9: return 9 - (point - 9) return point class Turtle(Father): def __init__(self): super(Turtle, self).__init__() self.power = 100 def move(self): super(Turtle, self).__init__() move_skill = [-1, 1, 0, -2, 2] new_x = self.x + random.choice(move_skill) new_y = self.y + random.choice(move_skill) self.x = self.is_vaild(new_x) self.y = self.is_vaild(new_y) self.power -= 1 def eat(self): self.power += 20 if self.power >=200: self.power = 200 class Fish(Father): def move(self): move_skill = [-1, 1, 0] new_x = self.x + random.choice(move_skill) new_y = self.y + random.choice(move_skill) self.x = self.is_vaild(new_x) self.y = self.is_vaild(new_y) def main(): t1 = Turtle() fish = [Fish() for i in range(10)] while True: if t1.power <= 0: print('乌龟累死了......') break elif len(fish) == 0: print('鱼被吃光,乌龟赢了!!!') break else: t1.move() for fishs in fish: fishs.move() if t1.x == fishs.x and t1.y == fishs.y: t1.eat() fish.remove(fishs) print('鱼被吃掉了.....') print('乌龟的最新体能%s'%(t1.power)) else: print('乌龟没有吃掉鱼,体力值还有:%s'%(t1.power)) # if __name__ =="__main__": # main()
我们遵循上面继承的原则,把重复性的方法都归为父类,其他不变同样也可以为我们得到游戏结果。
小结:
继承可以把父类的所有功能都直接拿过来,这样就不必重零做起,子类只需要新增自己特有的方法,也可以把父类不适合的方法覆盖重写。