1.15一个类的实例：继承、多态

前言

在本节中我们将编写两个类：

• Person：一个创建并处理人员相关信息的类。
• Manager：一个定制化的Person，修改了所继承的行为。

步骤一：创建实例

在python中，模块名使用小写字母开头，而类名使用大写字母开头，这是通用的惯例。我们新的模块文件的命名为person.py。

class Person: 

一个模块文件中可以编写任意多的函数和类，但是如果添加了太多与模块不相关的内容，那么我们person.py的名称就意义不大了。当模块拥有一个单一、内聚的用途的时候，他们工作的会更好。
编写构造函数
给实例属性赋初值得常见方法是在_init_构造函数方法中将初值赋给self。构造函数包含了每次创建一个实例时python都会自动运行的代码。

class Person:
    def __init__(self, name, job, pay):
        self.name = name
        self.job = job
        self.pay = pay

我们传入的数据作为构造函数方法的参数附加到一个实例上，并且将它们赋给self以长期持有。self就是新创建的实例对象，而name、job、pay则是状态信息，即保存在对象中供随后使用的描述性数据。
测试
编写测试代码：

class Person:
    def __init__(self, name, job, pay):
        self.name = name
        self.job = job
        self.pay = pay


if __name__ == "__main__":
    bob = Person("Bob Smith", "dev", "10k")
    sue = Person(name="Sue jones", job="test", pay="8k")
    print("{0} {1} {2}".format(bob.name, bob.job, bob.pay))
    print(sue.name, sue.job, sue.pay)

__name__模块检查用于解决只有当文件作为测试运行而不是导入的时候，才执行文件底部的测试语句。只有当把文件作为顶层脚本运行的时候才测试它，因为这个时候的__name__是__main__。但当做模块导入的时候，则__name__等于模块名称。
两种使用代码的方式：

C:\code>python person.py
Bob Smith dev 10k
Sue jones test 8k

Python 3.7.4 (default, Oct 12 2019, 19:06:48)
[Clang 11.0.0 (clang-1100.0.33.8)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> import person
>>>

当被导入时，文件定义了类却没有使用它。当直接运行时，文件创建了类的两个实例，并且打印了每个实例的两个属性。

步骤二：添加行为方法

我们要把操作对象的代码编写到类方法中，而不是分散在整个整个程序中。这里就一种封装的思想，就是把操作逻辑的包装到接口之后，这样每种操作在我们的程序中只会编写一次，通过这种方式，如果将来需要修改，那么只需修改一个版本。

class Person:
    def __init__(self, name, job, pay):
        self.name = name
        self.job = job
        self.pay = pay

    def lastName(self):
        return self.name.split()[-1]

    def giveRaise(self, percent):
        self.pay = int(self.pay * (1 + percent))


if __name__ == "__main__":
    bob = Person("Bob Smith", "dev", 10000)
    sue = Person(name="Sue jones", job="test", pay=8000)
    print("{0} {1} {2}".format(bob.name, bob.job, bob.pay))
    print(sue.name, sue.job, sue.pay)
    print(bob.lastName(), sue.lastName())
    sue.giveRaise(0.10)
    print(sue.pay)

C:\code>python person.py
Bob Smith dev 10K
Sue jones test 8000
Smith jones
8800

方法只是附加给类并旨在处理类的实例的常规函数。实例是方法调用的主体，并且会自动传给方法的self参数。

• 在第一个调用 bob.lastName()中，bob是传给self的隐含主体。
• 在第二个调用 sue.lastName()中，sue被传给了self。

步骤三：运算符重载

当我们需要跟踪一个对象的时候，我们发现实例对象默认的显示格式并不是很友好，它显示的是对象的类名以及在内存中的地址。

 print("bob:{}".format(bob))
 print("sue:{}".format(sue))

bob:<__main__.Person object at 0x1056621d0>
sue:<__main__.Person object at 0x105662210>

我们可以通过使用运算符重载来做出更友好的输出——在一个类中编写这样的方法，当方法在类的实例上运行的时候，方法拦截并处理内置的操作。我们可以使用排在__init__之后第二个常用的运算符重载方法__repr__，以及__repr__的孪生兄弟__str__。每次一个实例转化为其打印字符串的时候，该方法都会自动运行。打印一个对象会显示该对象的__str__或__repr__方法（要么是自己定义的，要么是从父类继承的）所返回的内容。

class Person:
    def __init__(self, name, job, pay):
        self.name = name
        self.job = job
        self.pay = pay

    def lastName(self):
        return self.name.split()[-1]

    def giveRaise(self, percent):
        self.pay = int(self.pay * (1 + percent))
    def __str__(self):
        return '[Person_str:%s, %s, %s]' % (self.name, self.job, self.pay)
    def __repr__(self):
        return '[Person_repr:%s, %s, %s]' % (self.name, self.job, self.pay)


if __name__ == "__main__":
    bob = Person("Bob Smith", "dev", 10000)
    sue = Person(name="Sue jones", job="test", pay=8000)
    print("bob:{}".format(bob))
    print("sue:{}".format(sue))

运行方式一

C:\code>python person.py
bob:[Person_str:Bob Smith, dev, 10000]
sue:[Person_str:Sue jones, test, 8000]

运行方式二

Python 3.7.4 (default, Oct 12 2019, 19:06:48)
[Clang 11.0.0 (clang-1100.0.33.8)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> from person import Person
>>> bob = Person("Bob Smith", "dev", 10000)
>>> bob
[Person_repr:Bob Smith, dev, 10000]
>>> print(bob)
[Person_str:Bob Smith, dev, 10000]

程序提示：调用print函数的时候使用__str__而交互式命令行调用__repr__。

步骤四：继承，编写子类(多态)

场景：我们来定义一个管理人员，管理人员每次涨工资的时候，除了像往常一样接受传入的百分比外，还会获得一个默认10%的额外奖金。即：如果一个管理人员加薪10%，那么它实际得到20%的增长。

class Manager(Person):
    def giveRaise(self, percent, bonus=.10):

现在有两种方式编写Manager的定制方法：一种好的方式和不好的方式。

• 不好的方式

class Manager(Person):
    def giveRaise(self, percent, bonus=.10):
        self.pay = int(self.pay * (1 + percent + bonus))

• 好的方式

class Manager(Person):
    def giveRaise(self, percent, bonus=.10):
        Person.giveRaise(self, percent + bonus)

不好的方式是直接复制粘贴代码，基本会使未来的维护工作翻倍。通过类直接调用有效的避开了继承的限制，从而能将调用直接定位到类树的某个特定版本。对于通过类名调用的方式，你需要自己给self传入一个实例，Manger类中对于giveRaise这样的一个内部代码，self已经是调用的主体，因此直接可以通过self传入对应的实例。
下面是本模块完整的代码：

class Person:
    def __init__(self, name, job, pay):
        self.name = name
        self.job = job
        self.pay = pay

    def lastName(self):
        return self.name.split()[-1]

    def giveRaise(self, percent):
        self.pay = int(self.pay * (1 + percent))

    def __str__(self):
        return '[%s_str:%s, %s, %s]' % (self.__class__.__name__, self.name, self.job, self.pay)

    def __repr__(self):
        return '[%s_repr:%s, %s, %s]' % (self.__class__.__name__, self.name, self.job, self.pay)


class Manager(Person):
    def giveRaise(self, percent, bonus=.10):
        Person.giveRaise(self, percent + bonus)


if __name__ == "__main__":
    sue = Person(name="Sue jones", job="test", pay=10000)
    print("sue:{}".format(sue))
    sue.giveRaise(.10)
    print("sue:{}".format(sue))
    tom = Manager("Tom Jones", "mgr", 10000)
    print("tom:{}".format(tom))
    tom.giveRaise(.10)
    print("tom:{}".format(tom))

C:\code>python person.py
sue:[Person_str:Sue jones, test, 10000]
sue:[Person_str:Sue jones, test, 11000]
tom:[Manager_str:Tom Jones, mgr, 10000]
tom:[Manager_str:Tom Jones, mgr, 12000]

我们从上面的结果可以看到，sue被分配到person中的giveRaise方法，而tom被分配到Manager中的giveRaise的方法。根据所传递的对象的类型，将会自动运行合适的版本，这就是多态。

步骤五：定制和调用父类的构造函数

我们创建Manager对象的时候，为它提供一个mgr的参数似乎是没有意义的，这已经包含在类中了。我们可以重新定制Manager中的__init__方法，提供mgr字符串。

class Person:
    def __init__(self, name, job, pay):
        self.name = name
        self.job = job
        self.pay = pay

    def lastName(self):
        return self.name.split()[-1]

    def giveRaise(self, percent):
        self.pay = int(self.pay * (1 + percent))

    def __str__(self):
        return '[%s_str:%s, %s, %s]' % (self.__class__.__name__, self.name, self.job, self.pay)

    def __repr__(self):
        return '[%s_repr:%s, %s, %s]' % (self.__class__.__name__, self.name, self.job, self.pay)


class Manager(Person):
    def __init__(self, name, pay):
        Person.__init__(self, name, 'mgr', pay)  # 调用父类的方法
    
    def giveRaise(self, percent, bonus=.10):
        Person.giveRaise(self, percent + bonus)


if __name__ == "__main__":
    sue = Person(name="Sue jones", job="test", pay=10000)
    print("sue:{}".format(sue))
    sue.giveRaise(.10)
    print("sue:{}".format(sue))
    tom = Manager("Tom Jones", 10000)  # 可以减少“mgr”参数
    print("tom:{}".format(tom))
    tom.giveRaise(.10)
    print("tom:{}".format(tom))