阿里云天池Python训练营-Part4.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "e756e0e1",
   "metadata": {},
   "source": [
    "本笔记为阿里云天池龙珠计划 Python 训练营的学习内容，链接为：https://tianchi.aliyun.com/specials/promotion/aicamppython\n",
    "# 阿里云天池 Python 训练营 [国际人学校 - 林肯老师 22 年情人节版本] - Part4\n",
    "\n",
    "![rhtKQR](https://upiclw.oss-cn-beijing.aliyuncs.com/uPic/rhtKQR.png)\n",
    "\n",
    "* 2022 年 02 月 14 日版本\n",
    "* 本文档是以 CC 开源的模式的发布，你能且将获得本文档的 PDF 版本已经 Jupyter Notebook 版本\n",
    "* 本文档并不申明自己的版权信息，为了更好的知识传播，我们授权你使用本文档，你可以使用它，进行二次创作，进行分发，进行修改，并可以以此为蓝本进行授课。\n",
    "* 请保留本文档的原始来源。\n",
    "* 本文档首先在国际人学校组织的“阿里云天池 Python 训练营课程”中使用。\n",
    "* 本文档由林肯老师首次组织和编辑。你可以通过网址 [数据大咖](https://www.shujudaka.com) 找到他。\n",
    "\n",
    "![TWy9b7](https://upiclw.oss-cn-beijing.aliyuncs.com/uPic/TWy9b7.jpg)\n",
    "\n",
    "## 19. 面向对象编程基础\n",
    "\n",
    "活在当下的程序员应该都听过 &quot; 面向对象编程 &quot; 一词，也经常有人问能不能用一句话解释下什么是 &quot; 面向对象编程 &quot;，我们先来看看比较正式的说法。\n",
    "\n",
    "&quot; 把一组数据结构和处理它们的方法组成对象（object），把相同行为的对象归纳为类（class），通过类的封装（encapsulation）隐藏内部细节，通过继承（inheritance）实现类的特化（specialization）和泛化（generalization），通过多态（polymorphism）实现基于对象类型的动态分派。&quot;\n",
    "\n",
    "> ** 说明：** 以上的内容来自于网络，不代表作者本人的观点和看法，与作者本人立场无关，相关责任不由作者承担。\n",
    "\n",
    "之前我们说过 &quot;** 程序是指令的集合 **&quot;，我们在程序中书写的语句在执行时会变成一条或多条指令然后由 CPU 去执行。当然为了简化程序的设计，我们引入了函数的概念，把相对独立且经常重复使用的代码放置到函数中，在需要使用这些功能的时候只要调用函数即可；如果一个函数的功能过于复杂和臃肿，我们又可以进一步将函数继续切分为子函数来降低系统的复杂性。但是说了这么多，不知道大家是否发现，所谓编程就是程序员按照计算机的工作方式控制计算机完成各种任务。但是，计算机的工作方式与正常人类的思维模式是不同的，如果编程就必须得抛弃人类正常的思维方式去迎合计算机，编程的乐趣就少了很多，&quot; 每个人都应该学习编程 &quot; 这样的豪言壮语就只能说说而已。当然，这些还不是最重要的，最重要的是当我们需要开发一个复杂的系统时，代码的复杂性会让开发和维护工作都变得举步维艰，所以在上世纪 60 年代末期，&quot;[软件危机](https://zh.wikipedia.org/wiki/%E8%BD%AF%E4%BB%B6%E5%8D%B1%E6%9C%BA)&quot;、&quot;[软件工程](https://zh.wikipedia.org/wiki/%E8%BD%AF%E4%BB%B6%E5%B7%A5%E7%A8%8B)&quot; 等一系列的概念开始在行业中出现。\n",
    "\n",
    "当然，程序员圈子内的人都知道，现实中并没有解决上面所说的这些问题的 &quot;[银弹](https://zh.wikipedia.org/wiki/%E6%B2%A1%E6%9C%89%E9%93%B6%E5%BC%B9)&quot;，真正让软件开发者看到希望的是上世纪 70 年代诞生的 [Smalltalk](https://zh.wikipedia.org/wiki/Smalltalk) 编程语言中引入的面向对象的编程思想（面向对象编程的雏形可以追溯到更早期的 [Simula](https://zh.wikipedia.org/wiki/Simula) 语言）。按照这种编程理念，程序中的数据和操作数据的函数是一个逻辑上的整体，我们称之为“对象”，而我们解决问题的方式就是创建出需要的对象并向对象发出各种各样的消息，多个对象的协同工作最终可以让我们构造出复杂的系统来解决现实中的问题。\n",
    "\n",
    "> ** 说明：** 当然面向对象也不是解决软件开发中所有问题的最后的“银弹”，所以今天的高级程序设计语言几乎都提供了对多种编程范式的支持，Python 也不例外。\n",
    "\n",
    "### 19.1 类和对象\n",
    "\n",
    "简单的说，类是对象的蓝图和模板，而对象是类的实例。这个解释虽然有点像用概念在解释概念，但是从这句话我们至少可以看出，类是抽象的概念，而对象是具体的东西。在面向对象编程的世界中，一切皆为对象，对象都有属性和行为，每个对象都是独一无二的，而且对象一定属于某个类（型）。当我们把一大堆拥有共同特征的对象的静态特征（属性）和动态特征（行为）都抽取出来后，就可以定义出一个叫做“类”的东西。\n",
    "\n",
    "### 19.2 定义类\n",
    "\n",
    "在 Python 中可以使用 `class` 关键字定义类，然后在类中通过之前学习过的函数来定义方法，这样就可以将对象的动态特征描述出来，代码如下所示。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "676f288a",
   "metadata": {
    "attributes": {
     "classes": [
      "Python"
     ],
     "id": ""
    }
   },
   "outputs": [],
   "source": [
    "class Student(object):\n",
    "\n",
    "    # __init__ 是一个特殊方法用于在创建对象时进行初始化操作\n",
    "    # 通过这个方法我们可以为学生对象绑定 name 和 age 两个属性\n",
    "    def __init__(self, name, age):\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "\n",
    "    def study(self, course_name):\n",
    "        print('%s 正在学习 %s.' % (self.name, course_name))\n",
    "\n",
    "    # PEP 8 要求标识符的名字用全小写多个单词用下划线连接\n",
    "    # 但是部分程序员和公司更倾向于使用驼峰命名法(驼峰标识)\n",
    "    def watch_movie(self):\n",
    "        if self.age < 18:\n",
    "            print('%s 只能观看《熊出没》.' % self.name)\n",
    "        else:\n",
    "            print('%s 正在观看岛国爱情大电影.' % self.name)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dfe86eae",
   "metadata": {},
   "source": [
    "> ** 说明：** 写在类中的函数，我们通常称之为（对象的）方法，这些方法就是对象可以接收的消息。\n",
    "\n",
    "### 19.3 创建和使用对象\n",
    "\n",
    "当我们定义好一个类之后，可以通过下面的方式来创建对象并给对象发消息。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e209c3c6",
   "metadata": {
    "attributes": {
     "classes": [
      "Python"
     ],
     "id": ""
    }
   },
   "outputs": [],
   "source": [
    "def main():\n",
    "    # 创建学生对象并指定姓名和年龄\n",
    "    stu1 = Student('骆昊', 38)\n",
    "    # 给对象发 study 消息\n",
    "    stu1.study('Python 程序设计')\n",
    "    # 给对象发 watch_av 消息\n",
    "    stu1.watch_movie()stu2 = Student('王大锤', 15)\n",
    "    stu2.study('思想品德')\n",
    "    stu2.watch_movie()\n",
    "\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    main()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "68e6adfd",
   "metadata": {},
   "source": [
    "### 19.4 访问可见性问题\n",
    "\n",
    "对于上面的代码，有 C++、Java、C# 等编程经验的程序员可能会问，我们给 `Student` 对象绑定的 `name` 和 `age` 属性到底具有怎样的访问权限（也称为可见性）。因为在很多面向对象编程语言中，我们通常会将对象的属性设置为私有的（private）或受保护的（protected），简单的说就是不允许外界访问，而对象的方法通常都是公开的（public），因为公开的方法就是对象能够接受的消息。在 Python 中，属性和方法的访问权限只有两种，也就是公开的和私有的，如果希望属性是私有的，在给属性命名时可以用两个下划线作为开头，下面的代码可以验证这一点。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "893a1304",
   "metadata": {
    "attributes": {
     "classes": [
      "Python"
     ],
     "id": ""
    }
   },
   "outputs": [],
   "source": [
    "class Test:\n",
    "\n",
    "    def __init__(self, foo):\n",
    "        self.__foo = foo\n",
    "\n",
    "    def __bar(self):\n",
    "        print(self.__foo)\n",
    "        print('__bar')\n",
    "\n",
    "\n",
    "def main():\n",
    "    test = Test('hello')\n",
    "    # AttributeError: 'Test' object has no attribute '__bar'\n",
    "    test.__bar()\n",
    "    # AttributeError: 'Test' object has no attribute '__foo'\n",
    "    print(test.__foo)\n",
    "\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    main()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9df9185b",
   "metadata": {},
   "source": [
    "但是，Python 并没有从语法上严格保证私有属性或方法的私密性，它只是给私有的属性和方法换了一个名字来妨碍对它们的访问，事实上如果你知道更换名字的规则仍然可以访问到它们，下面的代码就可以验证这一点。之所以这样设定，可以用这样一句名言加以解释，就是 &quot;**We are all consenting adults here**&quot;。因为绝大多数程序员都认为开放比封闭要好，而且程序员要自己为自己的行为负责。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "aa98eebe",
   "metadata": {
    "attributes": {
     "classes": [
      "Python"
     ],
     "id": ""
    }
   },
   "outputs": [],
   "source": [
    "class Test:\n",
    "\n",
    "    def __init__(self, foo):\n",
    "        self.__foo = foo\n",
    "\n",
    "    def __bar(self):\n",
    "        print(self.__foo)\n",
    "        print('__bar')\n",
    "\n",
    "\n",
    "def main():\n",
    "    test = Test('hello')\n",
    "    test._Test__bar()print(test._Test__foo)\n",
    "\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    main()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7a0c00cb",
   "metadata": {},
   "source": [
    "在实际开发中，我们并不建议将属性设置为私有的，因为这会导致子类无法访问（后面会讲到）。所以大多数 Python 程序员会遵循一种命名惯例就是让属性名以单下划线开头来表示属性是受保护的，本类之外的代码在访问这样的属性时应该要保持慎重。这种做法并不是语法上的规则，单下划线开头的属性和方法外界仍然是可以访问的，所以更多的时候它是一种暗示或隐喻。\n",
    "\n",
    "### 19.5 面向对象的支柱\n",
    "\n",
    "面向对象有三大支柱：\n",
    "封装、继承和多态。\n",
    "后面两个概念在下一个章节中进行详细的说明，这里我们先说一下什么是封装。\n",
    "\n",
    "我自己对封装的理解是 &quot; 隐藏一切可以隐藏的实现细节，只向外界暴露（提供）简单的编程接口 &quot;。我们在类中定义的方法其实就是把数据和对数据的操作封装起来了，在我们创建了对象之后，只需要给对象发送一个消息（调用方法）就可以执行方法中的代码，也就是说我们只需要知道方法的名字和传入的参数（方法的外部视图），而不需要知道方法内部的实现细节（方法的内部视图）。\n",
    "\n",
    "### 19.6 练习\n",
    "\n",
    "#### 练习 1：定义一个类描述数字时钟。\n",
    "\n",
    "参考答案："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5c193d65",
   "metadata": {
    "attributes": {
     "classes": [
      "Python"
     ],
     "id": ""
    }
   },
   "outputs": [],
   "source": [
    "from time import sleep\n",
    "\n",
    "\n",
    "class Clock(object):\n",
    "    \"\"\" 数字时钟 \"\"\"\n",
    "\n",
    "    def __init__(self, hour=0, minute=0, second=0):\n",
    "        \"\"\" 初始化方法\n",
    "\n",
    "        :param hour: 时\n",
    "        :param minute: 分\n",
    "        :param second: 秒\n",
    "        \"\"\"\n",
    "        self._hour = hour\n",
    "        self._minute = minute\n",
    "        self._second = second\n",
    "\n",
    "    def run(self):\n",
    "        \"\"\" 走字 \"\"\"\n",
    "        self._second += 1\n",
    "        if self._second == 60:\n",
    "            self._second = 0\n",
    "            self._minute += 1\n",
    "            if self._minute == 60:\n",
    "                self._minute = 0\n",
    "                self._hour += 1\n",
    "                if self._hour == 24:\n",
    "                    self._hour = 0\n",
    "\n",
    "    def show(self):\n",
    "        \"\"\" 显示时间 \"\"\"\n",
    "        return '%02d:%02d:%02d' % \\\n",
    "               (self._hour, self._minute, self._second)\n",
    "\n",
    "\n",
    "def main():\n",
    "    clock = Clock(23, 59, 58)\n",
    "    while True:\n",
    "        print(clock.show())\n",
    "        sleep(1)\n",
    "        clock.run()\n",
    "\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    main()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a1356ce3",
   "metadata": {},
   "source": [
    "#### 练习 2：定义一个类描述平面上的点并提供移动点和计算到另一个点距离的方法。\n",
    "\n",
    "参考答案："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8bed0879",
   "metadata": {
    "attributes": {
     "classes": [
      "Python"
     ],
     "id": ""
    }
   },
   "outputs": [],
   "source": [
    "from math import sqrt\n",
    "\n",
    "\n",
    "class Point(object):\n",
    "\n",
    "    def __init__(self, x=0, y=0):\n",
    "        \"\"\" 初始化方法\n",
    "        \n",
    "        :param x: 横坐标\n",
    "        :param y: 纵坐标\n",
    "        \"\"\"\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "\n",
    "    def move_to(self, x, y):\n",
    "        \"\"\" 移动到指定位置\n",
    "        \n",
    "        :param x: 新的横坐标\n",
    "        \"param y: 新的纵坐标\"\"\"\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "\n",
    "    def move_by(self, dx, dy):\n",
    "        \"\"\" 移动指定的增量\n",
    "        \n",
    "        :param dx: 横坐标的增量\n",
    "        \"param dy: 纵坐标的增量\"\"\"\n",
    "        self.x += dx\n",
    "        self.y += dy\n",
    "\n",
    "    def distance_to(self, other):\n",
    "        \"\"\" 计算与另一个点的距离\n",
    "        \n",
    "        :param other: 另一个点\n",
    "        \"\"\"\n",
    "        dx = self.x - other.x\n",
    "        dy = self.y - other.y\n",
    "        return sqrt(dx ** 2 + dy ** 2)\n",
    "\n",
    "    def __str__(self):\n",
    "        return '(%s, %s)' % (str(self.x), str(self.y))\n",
    "\n",
    "\n",
    "def main():\n",
    "    p1 = Point(3, 5)\n",
    "    p2 = Point()print(p1)\n",
    "    print(p2)\n",
    "    p2.move_by(-1, 2)\n",
    "    print(p2)\n",
    "    print(p1.distance_to(p2))\n",
    "\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    main()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "02496802",
   "metadata": {},
   "source": [
    "> ** 说明：** 本章中的插图来自于 Grady Booch 等著作的 [《面向对象分析与设计》](https://item.jd.com/20476561918.html) 一书，该书是讲解面向对象编程的经典著作，有兴趣的读者可以购买和阅读这本书来了解更多的面向对象的相关知识。\n",
    "\n",
    "\n",
    "## 20. 面向对象进阶\n",
    "\n",
    "在前面的章节我们已经了解了面向对象的入门知识，知道了如何定义类，如何创建对象以及如何给对象发消息。为了能够更好的使用面向对象编程思想进行程序开发，我们还需要对Python中的面向对象编程进行更为深入的了解。\n",
    "\n",
    "### 20.1 @property装饰器\n",
    "\n",
    "之前我们讨论过Python中属性和方法访问权限的问题，虽然我们不建议将属性设置为私有的，但是如果直接将属性暴露给外界也是有问题的，比如我们没有办法检查赋给属性的值是否有效。我们之前的建议是将属性命名以单下划线开头，通过这种方式来暗示属性是受保护的，不建议外界直接访问，那么如果想访问属性可以通过属性的getter（访问器）和setter（修改器）方法进行对应的操作。如果要做到这点，就可以考虑使用@property包装器来包装getter和setter方法，使得对属性的访问既安全又方便，代码如下所示。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "95937fdb",
   "metadata": {
    "attributes": {
     "classes": [
      "Python"
     ],
     "id": ""
    }
   },
   "outputs": [],
   "source": [
    "class Person(object):\n",
    "\n",
    "    def __init__(self, name, age):\n",
    "        self._name = name\n",
    "        self._age = age\n",
    "\n",
    "    # 访问器 - getter方法\n",
    "    @property\n",
    "    def name(self):\n",
    "        return self._name\n",
    "\n",
    "    # 访问器 - getter方法\n",
    "    @property\n",
    "    def age(self):\n",
    "        return self._age\n",
    "\n",
    "    # 修改器 - setter方法\n",
    "    @age.setter\n",
    "    def age(self, age):\n",
    "        self._age = age\n",
    "\n",
    "    def play(self):\n",
    "        if self._age <= 16:\n",
    "            print('%s正在玩飞行棋.' % self._name)\n",
    "        else:\n",
    "            print('%s正在玩斗地主.' % self._name)\n",
    "\n",
    "\n",
    "def main():\n",
    "    person = Person('王大锤', 12)\n",
    "    person.play()\n",
    "    person.age = 22\n",
    "    person.play()\n",
    "    # person.name = '白元芳'  # AttributeError: can't set attribute\n",
    "\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    main()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f196fc11",
   "metadata": {},
   "source": [
    "### 20.2 __slots__魔法\n",
    "\n",
    "我们讲到这里，不知道大家是否已经意识到，Python是一门[动态语言](https://zh.wikipedia.org/wiki/%E5%8A%A8%E6%80%81%E8%AF%AD%E8%A8%80)。通常，动态语言允许我们在程序运行时给对象绑定新的属性或方法，当然也可以对已经绑定的属性和方法进行解绑定。但是如果我们需要限定自定义类型的对象只能绑定某些属性，可以通过在类中定义__slots__变量来进行限定。需要注意的是__slots__的限定只对当前类的对象生效，对子类并不起任何作用。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f3800807",
   "metadata": {
    "attributes": {
     "classes": [
      "Python"
     ],
     "id": ""
    }
   },
   "outputs": [],
   "source": [
    "class Person(object):\n",
    "\n",
    "    # 限定Person对象只能绑定_name, _age和_gender属性\n",
    "    __slots__ = ('_name', '_age', '_gender')\n",
    "\n",
    "    def __init__(self, name, age):\n",
    "        self._name = name\n",
    "        self._age = age\n",
    "\n",
    "    @property\n",
    "    def name(self):\n",
    "        return self._name\n",
    "\n",
    "    @property\n",
    "    def age(self):\n",
    "        return self._age\n",
    "\n",
    "    @age.setter\n",
    "    def age(self, age):\n",
    "        self._age = age\n",
    "\n",
    "    def play(self):\n",
    "        if self._age <= 16:\n",
    "            print('%s正在玩飞行棋.' % self._name)\n",
    "        else:\n",
    "            print('%s正在玩斗地主.' % self._name)\n",
    "\n",
    "\n",
    "def main():\n",
    "    person = Person('王大锤', 22)\n",
    "    person.play()\n",
    "    person._gender = '男'\n",
    "    # AttributeError: 'Person' object has no attribute '_is_gay'\n",
    "    # person._is_gay = True"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "498a0574",
   "metadata": {},
   "source": [
    "### 20.3 静态方法和类方法\n",
    "\n",
    "之前，我们在类中定义的方法都是对象方法，也就是说这些方法都是发送给对象的消息。实际上，我们写在类中的方法并不需要都是对象方法，例如我们定义一个“三角形”类，通过传入三条边长来构造三角形，并提供计算周长和面积的方法，但是传入的三条边长未必能构造出三角形对象，因此我们可以先写一个方法来验证三条边长是否可以构成三角形，这个方法很显然就不是对象方法，因为在调用这个方法时三角形对象尚未创建出来（因为都不知道三条边能不能构成三角形），所以这个方法是属于三角形类而并不属于三角形对象的。我们可以使用静态方法来解决这类问题，代码如下所示。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d65c35d6",
   "metadata": {
    "attributes": {
     "classes": [
      "Python"
     ],
     "id": ""
    }
   },
   "outputs": [],
   "source": [
    "from math import sqrt\n",
    "\n",
    "\n",
    "class Triangle(object):\n",
    "\n",
    "    def __init__(self, a, b, c):\n",
    "        self._a = a\n",
    "        self._b = b\n",
    "        self._c = c\n",
    "\n",
    "    @staticmethod\n",
    "    def is_valid(a, b, c):\n",
    "        return a + b > c and b + c > a and a + c > b\n",
    "\n",
    "    def perimeter(self):\n",
    "        return self._a + self._b + self._c\n",
    "\n",
    "    def area(self):\n",
    "        half = self.perimeter() / 2\n",
    "        return sqrt(half * (half - self._a) *\n",
    "                    (half - self._b) * (half - self._c))\n",
    "\n",
    "\n",
    "def main():\n",
    "    a, b, c = 3, 4, 5\n",
    "    # 静态方法和类方法都是通过给类发消息来调用的\n",
    "    if Triangle.is_valid(a, b, c):\n",
    "        t = Triangle(a, b, c)\n",
    "        print(t.perimeter())\n",
    "        # 也可以通过给类发消息来调用对象方法但是要传入接收消息的对象作为参数\n",
    "        # print(Triangle.perimeter(t))\n",
    "        print(t.area())\n",
    "        # print(Triangle.area(t))\n",
    "    else:\n",
    "        print('无法构成三角形.')\n",
    "\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    main()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "30c24400",
   "metadata": {},
   "source": [
    "和静态方法比较类似，Python还可以在类中定义类方法，类方法的第一个参数约定名为cls，它代表的是当前类相关的信息的对象（类本身也是一个对象，有的地方也称之为类的元数据对象），通过这个参数我们可以获取和类相关的信息并且可以创建出类的对象，代码如下所示。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1bf012b3",
   "metadata": {
    "attributes": {
     "classes": [
      "Python"
     ],
     "id": ""
    }
   },
   "outputs": [],
   "source": [
    "from time import time, localtime, sleep\n",
    "\n",
    "\n",
    "class Clock(object):\n",
    "    \"\"\"数字时钟\"\"\"\n",
    "\n",
    "    def __init__(self, hour=0, minute=0, second=0):\n",
    "        self._hour = hour\n",
    "        self._minute = minute\n",
    "        self._second = second\n",
    "\n",
    "    @classmethod\n",
    "    def now(cls):\n",
    "        ctime = localtime(time())\n",
    "        return cls(ctime.tm_hour, ctime.tm_min, ctime.tm_sec)\n",
    "\n",
    "    def run(self):\n",
    "        \"\"\"走字\"\"\"\n",
    "        self._second += 1\n",
    "        if self._second == 60:\n",
    "            self._second = 0\n",
    "            self._minute += 1\n",
    "            if self._minute == 60:\n",
    "                self._minute = 0\n",
    "                self._hour += 1\n",
    "                if self._hour == 24:\n",
    "                    self._hour = 0\n",
    "\n",
    "    def show(self):\n",
    "        \"\"\"显示时间\"\"\"\n",
    "        return '%02d:%02d:%02d' % \\\n",
    "               (self._hour, self._minute, self._second)\n",
    "\n",
    "\n",
    "def main():\n",
    "    # 通过类方法创建对象并获取系统时间\n",
    "    clock = Clock.now()\n",
    "    while True:\n",
    "        print(clock.show())\n",
    "        sleep(1)\n",
    "        clock.run()\n",
    "\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    main()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "11922724",
   "metadata": {},
   "source": [
    "### 20.4 类之间的关系\n",
    "\n",
    "简单的说，类和类之间的关系有三种：is-a、has-a和use-a关系。\n",
    "\n",
    "- is-a关系也叫继承或泛化，比如学生和人的关系、手机和电子产品的关系都属于继承关系。\n",
    "- has-a关系通常称之为关联，比如部门和员工的关系，汽车和引擎的关系都属于关联关系；关联关系如果是整体和部分的关联，那么我们称之为聚合关系；如果整体进一步负责了部分的生命周期（整体和部分是不可分割的，同时同在也同时消亡），那么这种就是最强的关联关系，我们称之为合成关系。\n",
    "- use-a关系通常称之为依赖，比如司机有一个驾驶的行为（方法），其中（的参数）使用到了汽车，那么司机和汽车的关系就是依赖关系。\n",
    "\n",
    "我们可以使用一种叫做[UML](https://zh.wikipedia.org/wiki/%E7%BB%9F%E4%B8%80%E5%BB%BA%E6%A8%A1%E8%AF%AD%E8%A8%80)（统一建模语言）的东西来进行面向对象建模，其中一项重要的工作就是把类和类之间的关系用标准化的图形符号描述出来。关于UML我们在这里不做详细的介绍，有兴趣的读者可以自行阅读[《UML面向对象设计基础》](https://e.jd.com/30392949.html)一书。\n",
    "\n",
    "![0Tuscv](https://oss.images.shujudaka.com/uPic/0Tuscv.jpg)\n",
    "\n",
    "![ejExrm](https://oss.images.shujudaka.com/uPic/ejExrm.jpg)\n",
    "\n",
    "利用类之间的这些关系，我们可以在已有类的基础上来完成某些操作，也可以在已有类的基础上创建新的类，这些都是实现代码复用的重要手段。复用现有的代码不仅可以减少开发的工作量，也有利于代码的管理和维护，这是我们在日常工作中都会使用到的技术手段。\n",
    "\n",
    "### 20.5 继承和多态\n",
    "\n",
    "刚才我们提到了，可以在已有类的基础上创建新类，这其中的一种做法就是让一个类从另一个类那里将属性和方法直接继承下来，从而减少重复代码的编写。提供继承信息的我们称之为父类，也叫超类或基类；得到继承信息的我们称之为子类，也叫派生类或衍生类。子类除了继承父类提供的属性和方法，还可以定义自己特有的属性和方法，所以子类比父类拥有的更多的能力，在实际开发中，我们经常会用子类对象去替换掉一个父类对象，这是面向对象编程中一个常见的行为，对应的原则称之为[里氏替换原则](https://zh.wikipedia.org/wiki/%E9%87%8C%E6%B0%8F%E6%9B%BF%E6%8D%A2%E5%8E%9F%E5%88%99)。下面我们先看一个继承的例子。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "376a2fc2",
   "metadata": {
    "attributes": {
     "classes": [
      "Python"
     ],
     "id": ""
    }
   },
   "outputs": [],
   "source": [
    "class Person(object):\n",
    "    \"\"\"人\"\"\"\n",
    "\n",
    "    def __init__(self, name, age):\n",
    "        self._name = name\n",
    "        self._age = age\n",
    "\n",
    "    @property\n",
    "    def name(self):\n",
    "        return self._name\n",
    "\n",
    "    @property\n",
    "    def age(self):\n",
    "        return self._age\n",
    "\n",
    "    @age.setter\n",
    "    def age(self, age):\n",
    "        self._age = age\n",
    "\n",
    "    def play(self):\n",
    "        print('%s正在愉快的玩耍.' % self._name)\n",
    "\n",
    "    def watch_av(self):\n",
    "        if self._age >= 18:\n",
    "            print('%s正在观看爱情动作片.' % self._name)\n",
    "        else:\n",
    "            print('%s只能观看《熊出没》.' % self._name)\n",
    "\n",
    "\n",
    "class Student(Person):\n",
    "    \"\"\"学生\"\"\"\n",
    "\n",
    "    def __init__(self, name, age, grade):\n",
    "        super().__init__(name, age)\n",
    "        self._grade = grade\n",
    "\n",
    "    @property\n",
    "    def grade(self):\n",
    "        return self._grade\n",
    "\n",
    "    @grade.setter\n",
    "    def grade(self, grade):\n",
    "        self._grade = grade\n",
    "\n",
    "    def study(self, course):\n",
    "        print('%s的%s正在学习%s.' % (self._grade, self._name, course))\n",
    "\n",
    "\n",
    "class Teacher(Person):\n",
    "    \"\"\"老师\"\"\"\n",
    "\n",
    "    def __init__(self, name, age, title):\n",
    "        super().__init__(name, age)\n",
    "        self._title = title\n",
    "\n",
    "    @property\n",
    "    def title(self):\n",
    "        return self._title\n",
    "\n",
    "    @title.setter\n",
    "    def title(self, title):\n",
    "        self._title = title\n",
    "\n",
    "    def teach(self, course):\n",
    "        print('%s%s正在讲%s.' % (self._name, self._title, course))\n",
    "\n",
    "\n",
    "def main():\n",
    "    stu = Student('王大锤', 15, '初三')\n",
    "    stu.study('数学')\n",
    "    stu.watch_av()\n",
    "    t = Teacher('骆昊', 38, '砖家')\n",
    "    t.teach('Python程序设计')\n",
    "    t.watch_av()\n",
    "\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    main()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f891bcfb",
   "metadata": {},
   "source": [
    "子类在继承了父类的方法后，可以对父类已有的方法给出新的实现版本，这个动作称之为方法重写（override）。通过方法重写我们可以让父类的同一个行为在子类中拥有不同的实现版本，当我们调用这个经过子类重写的方法时，不同的子类对象会表现出不同的行为，这个就是多态（poly-morphism）。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "681c8ef6",
   "metadata": {
    "attributes": {
     "classes": [
      "Python"
     ],
     "id": ""
    }
   },
   "outputs": [],
   "source": [
    "from abc import ABCMeta, abstractmethod\n",
    "\n",
    "\n",
    "class Pet(object, metaclass=ABCMeta):\n",
    "    \"\"\"宠物\"\"\"\n",
    "\n",
    "    def __init__(self, nickname):\n",
    "        self._nickname = nickname\n",
    "\n",
    "    @abstractmethod\n",
    "    def make_voice(self):\n",
    "        \"\"\"发出声音\"\"\"\n",
    "        pass\n",
    "\n",
    "\n",
    "class Dog(Pet):\n",
    "    \"\"\"狗\"\"\"\n",
    "\n",
    "    def make_voice(self):\n",
    "        print('%s: 汪汪汪...' % self._nickname)\n",
    "\n",
    "\n",
    "class Cat(Pet):\n",
    "    \"\"\"猫\"\"\"\n",
    "\n",
    "    def make_voice(self):\n",
    "        print('%s: 喵...喵...' % self._nickname)\n",
    "\n",
    "\n",
    "def main():\n",
    "    pets = [Dog('旺财'), Cat('凯蒂'), Dog('大黄')]\n",
    "    for pet in pets:\n",
    "        pet.make_voice()\n",
    "\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    main()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a27ff9d0",
   "metadata": {},
   "source": [
    "在上面的代码中，我们将`Pet`类处理成了一个抽象类，所谓抽象类就是不能够创建对象的类，这种类的存在就是专门为了让其他类去继承它。Python从语法层面并没有像Java或C#那样提供对抽象类的支持，但是我们可以通过`abc`模块的`ABCMeta`元类和`abstractmethod`包装器来达到抽象类的效果，如果一个类中存在抽象方法那么这个类就不能够实例化（创建对象）。上面的代码中，`Dog`和`Cat`两个子类分别对`Pet`类中的`make_voice`抽象方法进行了重写并给出了不同的实现版本，当我们在`main`函数中调用该方法时，这个方法就表现出了多态行为（同样的方法做了不同的事情）。\n",
    "\n",
    "## 21. 综合案例\n",
    "\n",
    "### 案例1：奥特曼打小怪兽。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "acd7b63f",
   "metadata": {
    "attributes": {
     "classes": [
      "Python"
     ],
     "id": ""
    }
   },
   "outputs": [],
   "source": [
    "from abc import ABCMeta, abstractmethod\n",
    "from random import randint, randrange\n",
    "\n",
    "\n",
    "class Fighter(object, metaclass=ABCMeta):\n",
    "    \"\"\"战斗者\"\"\"\n",
    "\n",
    "    # 通过__slots__魔法限定对象可以绑定的成员变量\n",
    "    __slots__ = ('_name', '_hp')\n",
    "\n",
    "    def __init__(self, name, hp):\n",
    "        \"\"\"初始化方法\n",
    "\n",
    "        :param name: 名字\n",
    "        :param hp: 生命值\n",
    "        \"\"\"\n",
    "        self._name = name\n",
    "        self._hp = hp\n",
    "\n",
    "    @property\n",
    "    def name(self):\n",
    "        return self._name\n",
    "\n",
    "    @property\n",
    "    def hp(self):\n",
    "        return self._hp\n",
    "\n",
    "    @hp.setter\n",
    "    def hp(self, hp):\n",
    "        self._hp = hp if hp >= 0 else 0\n",
    "\n",
    "    @property\n",
    "    def alive(self):\n",
    "        return self._hp > 0\n",
    "\n",
    "    @abstractmethod\n",
    "    def attack(self, other):\n",
    "        \"\"\"攻击\n",
    "\n",
    "        :param other: 被攻击的对象\n",
    "        \"\"\"\n",
    "        pass\n",
    "\n",
    "\n",
    "class Ultraman(Fighter):\n",
    "    \"\"\"奥特曼\"\"\"\n",
    "\n",
    "    __slots__ = ('_name', '_hp', '_mp')\n",
    "\n",
    "    def __init__(self, name, hp, mp):\n",
    "        \"\"\"初始化方法\n",
    "\n",
    "        :param name: 名字\n",
    "        :param hp: 生命值\n",
    "        :param mp: 魔法值\n",
    "        \"\"\"\n",
    "        super().__init__(name, hp)\n",
    "        self._mp = mp\n",
    "\n",
    "    def attack(self, other):\n",
    "        other.hp -= randint(15, 25)\n",
    "\n",
    "    def huge_attack(self, other):\n",
    "        \"\"\"究极必杀技(打掉对方至少50点或四分之三的血)\n",
    "\n",
    "        :param other: 被攻击的对象\n",
    "\n",
    "        :return: 使用成功返回True否则返回False\n",
    "        \"\"\"\n",
    "        if self._mp >= 50:\n",
    "            self._mp -= 50\n",
    "            injury = other.hp * 3 // 4\n",
    "            injury = injury if injury >= 50 else 50\n",
    "            other.hp -= injury\n",
    "            return True\n",
    "        else:\n",
    "            self.attack(other)\n",
    "            return False\n",
    "\n",
    "    def magic_attack(self, others):\n",
    "        \"\"\"魔法攻击\n",
    "\n",
    "        :param others: 被攻击的群体\n",
    "\n",
    "        :return: 使用魔法成功返回True否则返回False\n",
    "        \"\"\"\n",
    "        if self._mp >= 20:\n",
    "            self._mp -= 20\n",
    "            for temp in others:\n",
    "                if temp.alive:\n",
    "                    temp.hp -= randint(10, 15)\n",
    "            return True\n",
    "        else:\n",
    "            return False\n",
    "\n",
    "    def resume(self):\n",
    "        \"\"\"恢复魔法值\"\"\"\n",
    "        incr_point = randint(1, 10)\n",
    "        self._mp += incr_point\n",
    "        return incr_point\n",
    "\n",
    "    def __str__(self):\n",
    "        return '~~~%s奥特曼~~~\\n' % self._name + \\\n",
    "            '生命值: %d\\n' % self._hp + \\\n",
    "            '魔法值: %d\\n' % self._mp\n",
    "\n",
    "\n",
    "class Monster(Fighter):\n",
    "    \"\"\"小怪兽\"\"\"\n",
    "\n",
    "    __slots__ = ('_name', '_hp')\n",
    "\n",
    "    def attack(self, other):\n",
    "        other.hp -= randint(10, 20)\n",
    "\n",
    "    def __str__(self):\n",
    "        return '~~~%s小怪兽~~~\\n' % self._name + \\\n",
    "            '生命值: %d\\n' % self._hp\n",
    "\n",
    "\n",
    "def is_any_alive(monsters):\n",
    "    \"\"\"判断有没有小怪兽是活着的\"\"\"\n",
    "    for monster in monsters:\n",
    "        if monster.alive > 0:\n",
    "            return True\n",
    "    return False\n",
    "\n",
    "\n",
    "def select_alive_one(monsters):\n",
    "    \"\"\"选中一只活着的小怪兽\"\"\"\n",
    "    monsters_len = len(monsters)\n",
    "    while True:\n",
    "        index = randrange(monsters_len)\n",
    "        monster = monsters[index]\n",
    "        if monster.alive > 0:\n",
    "            return monster\n",
    "\n",
    "\n",
    "def display_info(ultraman, monsters):\n",
    "    \"\"\"显示奥特曼和小怪兽的信息\"\"\"\n",
    "    print(ultraman)\n",
    "    for monster in monsters:\n",
    "        print(monster, end='')\n",
    "\n",
    "\n",
    "def main():\n",
    "    u = Ultraman('骆昊', 1000, 120)\n",
    "    m1 = Monster('狄仁杰', 250)\n",
    "    m2 = Monster('白元芳', 500)\n",
    "    m3 = Monster('王大锤', 750)\n",
    "    ms = [m1, m2, m3]\n",
    "    fight_round = 1\n",
    "    while u.alive and is_any_alive(ms):\n",
    "        print('========第%02d回合========' % fight_round)\n",
    "        m = select_alive_one(ms)  # 选中一只小怪兽\n",
    "        skill = randint(1, 10)   # 通过随机数选择使用哪种技能\n",
    "        if skill <= 6:  # 60%的概率使用普通攻击\n",
    "            print('%s使用普通攻击打了%s.' % (u.name, m.name))\n",
    "            u.attack(m)\n",
    "            print('%s的魔法值恢复了%d点.' % (u.name, u.resume()))\n",
    "        elif skill <= 9:  # 30%的概率使用魔法攻击(可能因魔法值不足而失败)\n",
    "            if u.magic_attack(ms):\n",
    "                print('%s使用了魔法攻击.' % u.name)\n",
    "            else:\n",
    "                print('%s使用魔法失败.' % u.name)\n",
    "        else:  # 10%的概率使用究极必杀技(如果魔法值不足则使用普通攻击)\n",
    "            if u.huge_attack(m):\n",
    "                print('%s使用究极必杀技虐了%s.' % (u.name, m.name))\n",
    "            else:\n",
    "                print('%s使用普通攻击打了%s.' % (u.name, m.name))\n",
    "                print('%s的魔法值恢复了%d点.' % (u.name, u.resume()))\n",
    "        if m.alive > 0:  # 如果选中的小怪兽没有死就回击奥特曼\n",
    "            print('%s回击了%s.' % (m.name, u.name))\n",
    "            m.attack(u)\n",
    "        display_info(u, ms)  # 每个回合结束后显示奥特曼和小怪兽的信息\n",
    "        fight_round += 1\n",
    "    print('\\n========战斗结束!========\\n')\n",
    "    if u.alive > 0:\n",
    "        print('%s奥特曼胜利!' % u.name)\n",
    "    else:\n",
    "        print('小怪兽胜利!')\n",
    "\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    main()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b1df7d9f",
   "metadata": {},
   "source": [
    "### 案例2：扑克游戏。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f68bc9c2",
   "metadata": {
    "attributes": {
     "classes": [
      "Python"
     ],
     "id": ""
    }
   },
   "outputs": [],
   "source": [
    "import random\n",
    "\n",
    "\n",
    "class Card(object):\n",
    "    \"\"\"一张牌\"\"\"\n",
    "\n",
    "    def __init__(self, suite, face):\n",
    "        self._suite = suite\n",
    "        self._face = face\n",
    "\n",
    "    @property\n",
    "    def face(self):\n",
    "        return self._face\n",
    "\n",
    "    @property\n",
    "    def suite(self):\n",
    "        return self._suite\n",
    "\n",
    "    def __str__(self):\n",
    "        if self._face == 1:\n",
    "            face_str = 'A'\n",
    "        elif self._face == 11:\n",
    "            face_str = 'J'\n",
    "        elif self._face == 12:\n",
    "            face_str = 'Q'\n",
    "        elif self._face == 13:\n",
    "            face_str = 'K'\n",
    "        else:\n",
    "            face_str = str(self._face)\n",
    "        return '%s%s' % (self._suite, face_str)\n",
    "    \n",
    "    def __repr__(self):\n",
    "        return self.__str__()\n",
    "\n",
    "\n",
    "class Poker(object):\n",
    "    \"\"\"一副牌\"\"\"\n",
    "\n",
    "    def __init__(self):\n",
    "        self._cards = [Card(suite, face) \n",
    "                       for suite in '♠♥♣♦'\n",
    "                       for face in range(1, 14)]\n",
    "        self._current = 0\n",
    "\n",
    "    @property\n",
    "    def cards(self):\n",
    "        return self._cards\n",
    "\n",
    "    def shuffle(self):\n",
    "        \"\"\"洗牌(随机乱序)\"\"\"\n",
    "        self._current = 0\n",
    "        random.shuffle(self._cards)\n",
    "\n",
    "    @property\n",
    "    def next(self):\n",
    "        \"\"\"发牌\"\"\"\n",
    "        card = self._cards[self._current]\n",
    "        self._current += 1\n",
    "        return card\n",
    "\n",
    "    @property\n",
    "    def has_next(self):\n",
    "        \"\"\"还有没有牌\"\"\"\n",
    "        return self._current < len(self._cards)\n",
    "\n",
    "\n",
    "class Player(object):\n",
    "    \"\"\"玩家\"\"\"\n",
    "\n",
    "    def __init__(self, name):\n",
    "        self._name = name\n",
    "        self._cards_on_hand = []\n",
    "\n",
    "    @property\n",
    "    def name(self):\n",
    "        return self._name\n",
    "\n",
    "    @property\n",
    "    def cards_on_hand(self):\n",
    "        return self._cards_on_hand\n",
    "\n",
    "    def get(self, card):\n",
    "        \"\"\"摸牌\"\"\"\n",
    "        self._cards_on_hand.append(card)\n",
    "\n",
    "    def arrange(self, card_key):\n",
    "        \"\"\"玩家整理手上的牌\"\"\"\n",
    "        self._cards_on_hand.sort(key=card_key)\n",
    "\n",
    "\n",
    "# 排序规则-先根据花色再根据点数排序\n",
    "def get_key(card):\n",
    "    return (card.suite, card.face)\n",
    "\n",
    "\n",
    "def main():\n",
    "    p = Poker()\n",
    "    p.shuffle()\n",
    "    players = [Player('东邪'), Player('西毒'), Player('南帝'), Player('北丐')]\n",
    "    for _ in range(13):\n",
    "        for player in players:\n",
    "            player.get(p.next)\n",
    "    for player in players:\n",
    "        print(player.name + ':', end=' ')\n",
    "        player.arrange(get_key)\n",
    "        print(player.cards_on_hand)\n",
    "\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    main()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "63c589e2",
   "metadata": {},
   "source": [
    ">**说明：** 大家可以自己尝试在上面代码的基础上写一个简单的扑克游戏，例如21点(Black Jack)，游戏的规则可以自己在网上找一找。\n",
    "\n",
    "### 案例3：工资结算系统。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0b556865",
   "metadata": {
    "attributes": {
     "classes": [
      "Python"
     ],
     "id": ""
    }
   },
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "某公司有三种类型的员工 分别是部门经理、程序员和销售员\n",
    "需要设计一个工资结算系统 根据提供的员工信息来计算月薪\n",
    "部门经理的月薪是每月固定15000元\n",
    "程序员的月薪按本月工作时间计算 每小时150元\n",
    "销售员的月薪是1200元的底薪加上销售额5%的提成\n",
    "\"\"\"\n",
    "from abc import ABCMeta, abstractmethod\n",
    "\n",
    "\n",
    "class Employee(object, metaclass=ABCMeta):\n",
    "    \"\"\"员工\"\"\"\n",
    "\n",
    "    def __init__(self, name):\n",
    "        \"\"\"\n",
    "        初始化方法\n",
    "\n",
    "        :param name: 姓名\n",
    "        \"\"\"\n",
    "        self._name = name\n",
    "\n",
    "    @property\n",
    "    def name(self):\n",
    "        return self._name\n",
    "\n",
    "    @abstractmethod\n",
    "    def get_salary(self):\n",
    "        \"\"\"\n",
    "        获得月薪\n",
    "\n",
    "        :return: 月薪\n",
    "        \"\"\"\n",
    "        pass\n",
    "\n",
    "\n",
    "class Manager(Employee):\n",
    "    \"\"\"部门经理\"\"\"\n",
    "\n",
    "    def get_salary(self):\n",
    "        return 15000.0\n",
    "\n",
    "\n",
    "class Programmer(Employee):\n",
    "    \"\"\"程序员\"\"\"\n",
    "\n",
    "    def __init__(self, name, working_hour=0):\n",
    "        super().__init__(name)\n",
    "        self._working_hour = working_hour\n",
    "\n",
    "    @property\n",
    "    def working_hour(self):\n",
    "        return self._working_hour\n",
    "\n",
    "    @working_hour.setter\n",
    "    def working_hour(self, working_hour):\n",
    "        self._working_hour = working_hour if working_hour > 0 else 0\n",
    "\n",
    "    def get_salary(self):\n",
    "        return 150.0 * self._working_hour\n",
    "\n",
    "\n",
    "class Salesman(Employee):\n",
    "    \"\"\"销售员\"\"\"\n",
    "\n",
    "    def __init__(self, name, sales=0):\n",
    "        super().__init__(name)\n",
    "        self._sales = sales\n",
    "\n",
    "    @property\n",
    "    def sales(self):\n",
    "        return self._sales\n",
    "\n",
    "    @sales.setter\n",
    "    def sales(self, sales):\n",
    "        self._sales = sales if sales > 0 else 0\n",
    "\n",
    "    def get_salary(self):\n",
    "        return 1200.0 + self._sales * 0.05\n",
    "\n",
    "\n",
    "def main():\n",
    "    emps = [\n",
    "        Manager('刘备'), Programmer('诸葛亮'),\n",
    "        Manager('曹操'), Salesman('荀彧'),\n",
    "        Salesman('吕布'), Programmer('张辽'),\n",
    "        Programmer('赵云')\n",
    "    ]\n",
    "    for emp in emps:\n",
    "        if isinstance(emp, Programmer):\n",
    "            emp.working_hour = int(input('请输入%s本月工作时间: ' % emp.name))\n",
    "        elif isinstance(emp, Salesman):\n",
    "            emp.sales = float(input('请输入%s本月销售额: ' % emp.name))\n",
    "        # 同样是接收get_salary这个消息但是不同的员工表现出了不同的行为(多态)\n",
    "        print('%s本月工资为: ￥%s元' %\n",
    "              (emp.name, emp.get_salary()))\n",
    "\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    main()"
   ]
  }
 ],
 "metadata": {},
 "nbformat": 4,
 "nbformat_minor": 5
}