python第37课练习—类和对象：面向对象编程

1、以下代码体现了面向对象编程的什么特征？

>>> 'FishC.com'.count('o')
1
>>> [1,1,2,3,5,8].count(1)
2
>>> (0,2,3,6,8,12).count(1)
0

答：体现了面向对象编程的多态特征。

2、当程序员不想把同一段代码写几次，他们发明了函数解决了这种情况。当程序员已经有了一个类，而又想建立一个非常相近的新类，他们会怎么做呢？

答：他们会定义一个新类继承已有这个类，这样子就只需要简单添加和重写需要的方法即可。
例如已有“龟类”，那么如果要重新定义一个“甲鱼类”，我们只需要让“甲鱼类”继承已有的“龟类”，然后重写壳的属性为“软的”即可（据说甲鱼的壳是软的）。

3、self参数的作用是什么？

答：绑定方法，据说有了这个参数，Python再也不会傻傻分不清是哪个对象在调用方法了，你可以认为方法中的self其实就是实例对象的唯一标志。

4、如果我们不希望对象的属性或方法被外部直接引用，我们可以怎么做？

答：我们可以在属性或方法名字前边加上双下划线，这样子从外部是无法直接访问到，会显示AttributeError错误。

>>> class Person:
    __name = '小甲鱼'
    def getName(self):
        return self.__name

>>> p = Person()
>>> p.__name
Traceback (most recent call last):
  File "<pyshell#17>", line 1, in <module>
    p.__name
AttributeError: 'Person' object has no attribute '__name'
>>> p.getName()
'小甲鱼'

我们把getName方法称之为“访问器”。Python事实上是采用一种叫“name mangling”技术，将双下划线开头的变量巧妙的改了个名字而已，我们仍然可以在外部通过“类名_变量名”的方式访问：

>>> p._Person__name
'小甲鱼'

当然我们并不提倡这种抬杠较真粗暴不文明的访问形式......

5、类在实例化后哪个方法会被自动调用？

答：init方法会在类实例化时被自动调用，我们称之为魔法方法。你可以重写这个方法，为对象定制初始化方案。

6、请解释下边代码错误的原因：

>>> class MyClass:
    name = 'FishC'
    def myFun(self):
        print('Hello FishC!')

>>> MyClass.name
'FishC'
>>> MyClass.myFun()
Traceback (most recent call last):
  File "<pyshell#6>", line 1, in <module>
    MyClass.myFun()
TypeError: myFun() missing 1 required positional argument: 'self'

答：首先你要明白类、类对象、实例对象是三个不同的名词。
我们常常说的类指的是类定义，由于“Python无处不对象”，所以当类定义完之后，自然就是类对象。在这个时候，你可以对类的属性（变量）进行直接访问（MyClass.name）。
一个类可以实例化出无数的对象（实例对象），Python为了区分是哪个对象调用了方法，于是要求方法必须绑定（通过self参数）才能调用。而未实例化的类对象直接调用方法，因为缺少self参数，所以就会报错。

练习

1、按照以下要求定义一个游乐园门票的类，并尝试计算2个成人+1个小孩平日票价。

• 平日票价100元
• 周末票价为平日的120%
• 儿童票半价
  代码清单：

class Ticket():
    def __init__(self,weekend=False,child=False):
        self.exp = 100
        if weekend:
            self.inc = 1.2
        else:
            self.inc = 1
        if child:
            self.discount = 0.5
        else:
            self.discount = 1
    def calcPrice(self,num):
        return self.exp * self.inc * self.discount * num
    
adult = Ticket()
child = Ticket(child=True)
print('2个成人 + 1个小孩平日票价为：%.2f' %(adult.calcPrice(2)+child.calcPrice(1)))

2、游戏编程：按以下要求定义一个乌龟类和鱼类并尝试编写游戏。（初学者有些困难）

• 假设游戏场景范围(x,y)为0<=x<=10,0<=y<=10;
• 游戏生成1只乌龟和10条鱼；
• 它们的移动方向均随机；
• 乌龟最大移动能力是2（它可以随机选择1还是2移动），鱼儿最大移动能力是1；
• 当移动到场景边缘，自动向反方向移动；
• 乌龟初始化体力为100（上限）；
• 乌龟每移动一次，体力消耗1；
• 当乌龟和鱼坐标重叠，乌龟吃掉鱼，乌龟体力增加20；
• 鱼暂不计算体力；
• 当乌龟体力值为0（挂掉）或者鱼儿的数量为0时游戏结束；
  代码清单：

import random as r

legal_x = [0,10]
legal_y = [0,10]

class Turtle:
    def __init__(self):
        # 初始体力
        self.power = 100
        # 初始位置随机
        self.x = r.randint(legal_x[0],legal_x[1])
        self.y = r.randint(legal_y[0],legal_y[1])

    def move(self):
        # 随机计算方向并移动到新位置(x,y)
        new_x = self.x + r.choice([1,2,-1,-2])
        new_y = self.x + r.choice([1,2,-1,-2])
        # 检查移动后是否超出场景X轴边界
        if new_x < legal_x[0]:
            self.x = legal_x[0] - (new_x - legal_x[0])
        elif new_x > legal_x[1]:
            self.x = legal_x[1] - (new_x - legal_x[1]) # 这里相当于用边界减去超出的距离差
        else:
            self.x = new_x
        # 检查移动后是否超出场景y轴边界
        if new_y < legal_y[0]:
            self.y = legal_y[0] - (new_y - legal_y[0])
        elif new_y > legal_y[1]:
            self.y = legal_y[1] - (new_y - legal_y[1])
        else:
            self.y = new_y
        # 体力消耗
        self.power -= 1 
        # 返回移动后的新位置
        return (self.x,self.y)

    def eat(self):
        self.power += 20
        if self.power > 100:
            self.power = 100

class Fish:
    def __init__(self):
        self.x = r.randint(legal_x[0],legal_x[1])
        self.y = r.randint(legal_y[0],legal_y[1])

    def move(self):
        # 随机计算方向并移动到新位置（x,y）
        new_x = self.x + r.choice([1,-1])
        new_y = self.y + r.choice([1,-1])
        # 检查移动后是否超出场景x轴边界
        if new_x < legal_x[0]:
            self.x = legal_x[0] - (new_x - legal_x[0])
        elif new_x > legal_x[1]:
            self.x = legal_x[1] - (new_y - legal_y[1])
        else:
            self.x = new_x
        # 检查移动后是否超出场景y轴边界
        if new_y < legal_y[0]:
            self.y = legal_y[0] - (new_y - legal_y[0])
        elif new_y > legal_y[1]:
            self.y = legal_y[1] - (new_y - legal_y[0])
        else:
            self.y = new_y
        # 返回移动后的位置
        return (self.x,self.y)

turtle = Turtle()
fish = []
for i in range(10):
    new_fish = Fish()
    fish.append(new_fish)

while True:
    if not len(fish):
        print('鱼儿都被吃完了，游戏结束！')
        break
    if not turtle.power:
        print('乌龟体力耗尽，挂掉了！')
        break
    
    pos = turtle.move()
    # 在迭代器中删除列表元素是非常危险的，经常会出现意想不到的问题，因为迭代器是直接引用列表的数据进行引用
    # 这里我们把列表拷贝给迭代器，然后对原列表进行删除操作就不会有问题了！
    for each_fish in fish[:]:
        if each_fish.move() == pos:
            # 鱼儿被吃掉了
            turtle.eat()
            fish.remove(each_fish)
            print('有一条鱼儿被吃掉了.....')