10 面向对象的编程
本章内容：
1、编写类
2、显示对象
3、灵活的初始化
4、设置函数和获取函数
5、继承
6、多态
7、更深入的学习
------------------------------------------
本章主要介绍，为什么Python是面向对象的编程语言（OOP）。所以，本章的内容主要围绕面向对象的编程语言的特点展开；
1、编写类
下面，先编写一个表示人的简单类：
# person.py class Person: """ Class to represent a person """ def __init__(self): self.name = '' self.age = 0
__init__ 使用来进行数据初始化的标准函数。
在这个函数中，我们只需要调用 Person() 对象，就可以使用 age 和 name 两个变量，但是这两个变量需要以句点表示的方式来指定数据；
另外一个难点就是 self 参数；在定义变量的时候，我们没有指定参数，而是通过 __init__函数调用了self参数，则是 person() 自己调用自己的意思；所以，self是一个指向对象本身的变量；
2、显示对象
方法是类中定义的函数；下面给上面Person类，添加一个方法，用于打印Person对象的内容：
# person.py class Person: """ Class to represent a person """ def __init__(self0): self.name = '' self.age = 0 def display(self): print("Person('%s',%d)" % (self.name, self.age))
方法display将person对象的内容适合程序眼阅读的方式打印到屏幕上
除了使用 display 的方法外，我们还可以使用其他的方式，来做的更好，让你能够定制对象以支持天衣无缝的打印。例如：特殊方法 __str__ 用于生成对象的字符串表示：
# person.py class Person(): #为了节省篇幅，省略了 __init__ def dsplay(self): print("Person('%s',%d)" % (self.name, self.age)) def __str__(self): return ("Person('%s',%d)" % (self.name, self.age))
运行结果如下：
同样，还可以使用str来简化display：
# person.py class Person: # 为了节省篇幅，省略了 __init__ def display(self): print(str(self)) def __str__(self): return "Person('%s', %d)" % (self.name, self.age)
也可以定义特殊方法 __repr__ ，它返回对象的“官方”表示，例如Person对象的默认官方表示不太实用：
通过添加方法 __repr__，我们可控制这里打印的字符串。在大多数类中，方法 __repr__ 都与方法 __str__ 相同：
# person.py class Person: # 为节省篇幅，省略了 __init__ def display(self): print(str(self)) def __str__(self): return "Person('%s', %d) % (self.name, self.age) def __repr__(self): return str(self)
3、灵活的初始化
当前，要创建具有特定姓名和年龄的Person对象，必须这样做：
一种更加方便的方式，在构造对象时，将姓名和年龄传递给__init__。为此，需要重写__init__。
# person.py class Person: def __init__(self, name= '', age = 0): self.name = name self.age = age
这样的话，初始化Person对象将简单的多；
由于__init__的参数有默认值，你甚至可以创建“空的”Person对象：
注意方法 __init__，我们在其中使用了self.name和name（以及self.age和age）。变量name指向传入__init__的值，而self.name指向存储在对象中的值。使用self能够更加清晰的指出谁是谁；
4、设置函数和获取函数
当前，我们可以使用句点表示法来读写Person()对象的name以及age值，如下：
这种做法存在一个问题是，可能不小心将年纪设置成 -45 或者 509 等不符合逻辑的数字。对于常规Python变量，无法对付给他的值进行限制。但在对象中，可编写特殊设置函数（setter）和获取函数（getter），对存取值的方式进行控制。
首先，添加一个设置函数，它仅仅提供的值合理时才修改age:
def set_age(self, age): if 0 < age <= 150: self.age = age
此时，定义一个不再该范围内的数值，则不会修改；
对于这种设置函数，一种常见的抱怨是，输入p.set_age(30)比输入p.age = 30更加繁琐。为了解决这个问题，我们可以使用特性装饰器（property decorator）。
特性装饰器：
它融变量的简洁和函数的灵活于一身。装饰器指出函数或者方法有点特殊，这里使用他们来知识设置函数和获取函数；
获取函数返回变量的值，我们将使用@property装饰器来指出这一点：
@property def age(self) """ Returns this person's age. """ return self.age
这里的age方法除必不可少的self外不接受任何参数。我们在它前面加上了 @property，指出这是一个获取函数。这个方法的名称将被用于设置变量。
我们还将底层变量self.age重命名为self._age。在对象变量前加上下划线是一种常见的做法，这里使用这种方式将这个变量与方法age区分开来。你需要将Person类中的每一个self.age替换为self._age。为保持一致性，最好也将self.name都替换为self._name。修改后的Person类类似于下面这样：
# person.py class Person: def __init__(self, name = '', age = 0): self._name = name self._age = age @property def age(self): return self._age def set_age(self, age): if 0 < age <= 150: self._age = age def display(self): print(self) def __str__(self): return "Person('%s', %d)" % (self._name, self._age) def __repr__(self): return str(self)
为了给age创建设置函数，我们将方法set_age重命名为age，并使用@age.setter进行装饰：
@age.setter def age(self, age): if 0 < age <= 150: self._age = age
修改完以后这样输出：
由于给age提供了设置函数和获取函数，编写的代码就像直接使用变量age，但差别在于：遇到代码p.age = -4时，Python实际上将调用方法age(self, age)；同样，遇到代码p.age时，将调用方法age(self)。这提供了如下优点：1、赋值语句很简单了 2、同时可控制变量的设置和获取方式；
私有变量：
依然可以直接访问self._age:
问题在于，直接修改 _age 可能导致对象不一致，因此通常不希望直接修改的情况发生；
为了降低变量self._age被直接修改的可能性，一种方式是将其重新命名为self._age，即在变量名开头包含两个下划线。两个下划线表明age是私有变量，不应在Person类外直接访问它。要直接访问self._age，需要在前面加上_Person，如下所示：
这虽然不能禁止你直接修改内部的变量，但是将无意间这样做的可能性几乎降到了零；
5、继承
继承是一种重用类的机制，让你能够这样创建全新的类：给基友类的副本添加变量方法；
假设我们要开发一款游戏，其中涉及人类玩家和计算机玩家，为此，可以创建一个player类，它包含所有玩家都由的东西，如得分和名称：
# players.py class Player: def __init__(self, name): self._name = name self._score = 0 def reset_score(self): self._score = 0 def incr_score(self): self._score = self._score + 1 def get_name(self): return self._name def __str__(self): return "name = '%s', score = %d" % (self._name, self._score) def __repr__(self): return 'Player(%s)' % str(self)
我们可以像下面这样使用Player对象：
咋们假设有两类玩家：人和计算机。主要差别在于，人通过键盘输入走法，而计算机使用函数生成走法。除此之外，这两类玩家相同，它们都由名称和得分；
下面来编写一个Human类，用于表示人类玩家。为此，一种办法是通过赋值并粘贴新建Player类的一个副本，再添加让玩家走棋的方法get_move(self)。这种办法虽然可行，但更好的做法是使用继承。我们可以让Human类继承Player类的所有变量和方法，这样就不需要再次编辑它们了：
class Human(Player): pass
在Python中，pass语句表示“什么都不做”。对human类来说，这是一个完整而实用的定义，它继承player类的代码，然我们能够像下面一样定义变量：
重写方法：
一个小瑕疵是，h的字符串表示为player，但更准确的说法应该是human。为修复这种问题，可给Human定义方法__repr__;
class Human(Player): def __repr__(self): return 'Human(%s)' % str(self)
这样结果显示如下：
这就是方法重写：Human中的方法__repr__重写了从Player那里继承的方法__repr__。这是定制派生类的常用方式；
class Computer(Player): def __repr__(self): return 'Computer(%s)' % str(self)
这三个类组成了一个小型的类层次结构。player为基类，而且他两个类都为派生类。
【基类常被称为父类，而派生类则被称为子类】
6、多态
为了演示OOP的威力，咋们来创建一个名为Undercut的简单游戏。在这个游戏中，两个玩家同时选择一个1-10的整数，如果一个玩家选择的整数比对方选择整数的小1，则该玩家获胜，否则算打平。例如，如果Thomas和Bonnie一起玩游戏Undercur，且他们选择的数字分别为9和10，则Thomas获胜；如果他们分别选择4和7，则打成平手；
下面是一个玩Undercut游戏的函数:
def play_undercut(p1, p2): p1.reset_score() p2.reset_score() m1 = p1.get_move() m2 = p2.get_move() print("%s move: %d" % (p1.get_name(), m1)) print("%s move: %d" % (p2.get_name(), m2)) if m1 == m2 -1: p1.incr_score() return p1, p2, '%s wins!' % p1.get_name() elif m2 == m1 -1: p2.incr_score() return p1, p2, '%s wins!' % p2.get_name() else： return p1, p2, 'draw: no winner'
其中，p1.get_move() 和 p2.get_move() 我们还没有实现这些函数，因为他们随有些而异。下面就来实现这些函数；
实现get_move函数：
虽然在游戏Undercut中，走法不过是选择1-10的数字，但任何计算机选择数字的方式截然不同。人类玩家通过键盘输入一个1-10的数字，而计算机玩家使用函数来选择数字。因此，Human和Commputer类需要专用的get_move(self)方法。
下面时候Human类的方法get_move():
class Human(Plays): def __repr__(self): return 'Human(%s)' % str(self) def get_move(self): while True: try: n = int(input('%s move (1 - 10): ' % self.get_name())) if 1 <= n <= 10: return n else: print('Oops!') except: print('Oops!')
上述代码不断要求用户输入一个1-10的整数，知道用户按要求做。try/except 机构用于铺货用户输入的不是整数（如two）时函数int引发的异常。
对于计算机玩家，我们让它返回一个1-10的随机数（如果需要，以后可改进计算机采取的策略）：
import random class Computer(Player): def __repr__(self): return 'Computer(%s)' % str(self) def get_move(self): return random.randint(1,10)
再关联上述代码，则可以执行该游戏；
7、更深入的学习
这里，我们主要了解面向对象设计模式。推荐《设计模式：可复用面向对象软件的基础》
