一、引例--乌龟吃鱼
利用上一节课我们学到的知识，我们可以写一个简单的乌龟吃鱼的游戏，规则如下：
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()
我们遵循上面继承的原则，把重复性的方法都归为父类，其他不变同样也可以为我们得到游戏结果。
小结：
继承可以把父类的所有功能都直接拿过来,这样就不必重零做起,子类只需要新增自己特有的方法,也可以把父类不适合的方法覆盖重写。