07.Classes_and_OOP.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "类是 Python 程序的组成单元，它是封装逻辑和数据的一种方式，就像函数和模块一样。类有三个重要的独到之处，使其在建立新对象时更为有用。\n",
    "\n",
    "- 多重实例\n",
    "      类是产生对象的工厂。每次调用一个类，就会产生一个有独立命名空间(namespace)的新对象。每个由类产生的对象都能读取类的属性，并获得自己的命名空间来存储数据，这些数据对每个对象来说都不同。\n",
    "      \n",
    "- 通过继承进行定制\n",
    "      类支持 OOP 继承的概念。我们可以在类的外部重新定义其属性从而扩充这个类。\n",
    "      \n",
    "- 运算符重载\n",
    "      通过提供特定的协议方法，类可以响应内置类型的运算。例如，通过类创建的对象可以进行切片和索引等运算。Python 提供了一些可以由类使用的钩子，从而能够中断并实现任何的内置类型运算。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "类是 Python 所提供的最有用的工具之一。合理使用类，可以大量减少开发的时间。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1. 类产生多个实例对象\n",
    "\n",
    "要了解多个对象是如何工作的，需要先了解 Python 的 OOP 模型中的两个对象：**类**对象(class object)和 **实例**对象(instance object)。\n",
    "\n",
    "- 类对象提供默认行为，是实例对象的工厂；实例对象是程序处理的实际对象。\n",
    "\n",
    "\n",
    "- 类对象来自于语句，而实例来自于调用。每次调用一个类，就会得到这个类的新实例。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 类对象提供默认行为\n",
    "\n",
    "在 Python 中，类的建立使用了一条新的语句：class 语句。执行 class 语句，就会得到一个类对象。以下是 Python 类对象主要特性：\n",
    "\n",
    "- class 语句创建类对象并将其赋值给变量名\n",
    "      就像函数 def 语句，Python class 语句也是可执行语句。执行时会产生新的类对象，并将其赋值给 class 头部的变量名。\n",
    "\n",
    "- class 语句内的赋值语句会创建类的属性\n",
    "      就像模块文件，class 语句内顶层的赋值语句（不是 def 之内）会产生类对象中的属性。\n",
    "      \n",
    "- 类属性提供对象的状态和行为\n",
    "      类对象的属性记录状态信息和行为，可由这个类所创建的所有实例共享。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 实例对象是具体的元素\n",
    "\n",
    "在调用类对象时，我们得到了实例对象。创建实例对象的动作叫做 **实例化**。\n",
    "\n",
    "- 像函数那样调用类对象会创建新的实例对象\n",
    "      每次类调用时，都会建立并返回新的实例对象。实例代表程序中的具体元素。\n",
    "      \n",
    "- 每个实例对象继承类的属性并获得自己的命名空间。\n",
    "      由类所创建的实例对象是新命名空间。\n",
    "\n",
    "- 在方法内对 self 属性做赋值运算会产生每个实例自己的属性\n",
    "      在类方法函数内，第一个参数（self）会引用正处理的实例对象。对 self 的属性做赋值运算，会创建或修改实例内的数据，而不是类的数据。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 第一个例子\n",
    "\n",
    "像所有复合语句一样，class 开头一行会列出类的名称，后面再接一个或多个内嵌并缩进的语句主体。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "code_folding": []
   },
   "outputs": [],
   "source": [
    "class FirstClass:      # Define a class object\n",
    "    def setdata(self, value):   # Define class's methods\n",
    "        self.data = value       # self is the instance\n",
    "    \n",
    "    def display(self):\n",
    "        print(self.data)        # self.data: per instance"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "setdata 和 display 位于 class 语句范围内，因此会产生附加在类上的属性（方法）：FirstClass.setdata 和 FirstClass.display。事实上，**在类嵌套的代码块中顶层赋值的任何变量名，都会变成类的属性**。\n",
    "\n",
    "位于类中的函数通常称为 **方法**。在调用方法函数时，第一个参数自动接收隐含的实例对象：调用的主体。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['__class__',\n",
       " '__delattr__',\n",
       " '__dict__',\n",
       " '__dir__',\n",
       " '__doc__',\n",
       " '__eq__',\n",
       " '__format__',\n",
       " '__ge__',\n",
       " '__getattribute__',\n",
       " '__gt__',\n",
       " '__hash__',\n",
       " '__init__',\n",
       " '__init_subclass__',\n",
       " '__le__',\n",
       " '__lt__',\n",
       " '__module__',\n",
       " '__ne__',\n",
       " '__new__',\n",
       " '__reduce__',\n",
       " '__reduce_ex__',\n",
       " '__repr__',\n",
       " '__setattr__',\n",
       " '__sizeof__',\n",
       " '__str__',\n",
       " '__subclasshook__',\n",
       " '__weakref__',\n",
       " 'display',\n",
       " 'setdata']"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dir(FirstClass)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "接下来，我们需要建立类的实例对象，进一步理解它是如何工作的："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "code_folding": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class '__main__.FirstClass'>\n",
      "<__main__.FirstClass object at 0x000002011AB975B0>\n",
      "<__main__.FirstClass object at 0x000002011AB97940>\n"
     ]
    }
   ],
   "source": [
    "# Make two instances, each is a new namespace\n",
    "x = FirstClass()\n",
    "y = FirstClass()\n",
    "print(type(x))\n",
    "print(x)\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "以此方式**调用**类时（注意小括号），会产生实例对象，Python 为每个实例对象分配独立的内存空间。（'\\_\\_main\\_\\_' 是顶层代码执行的作用域的名称）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "code_folding": [
     0
    ]
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<__main__.FirstClass object at 0x000002011AB97130>\n",
      "<__main__.FirstClass object at 0x000002011AB97130>\n"
     ]
    }
   ],
   "source": [
    "# Multiple-target assignment and shared references\n",
    "a = b = FirstClass()\n",
    "print(a)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "此时，有三个对象：一个类（FirstClass）和两个实例（x 和 y），它们的关系如下图所示。\n",
    "\n",
    "![img](images/chapter07/class_and_instances.png)\n",
    "\n",
    "这里，\"data\" 属性会在实例内找到，而 \"setdata\" 和 \"display\" 则是在类中找到。\n",
    "\n",
    "如果对实例以及类对象内的属性名称进行点号运算，Python 会通过继承搜索从类取得变量名。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "code_folding": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['__class__',\n",
       " '__delattr__',\n",
       " '__dict__',\n",
       " '__dir__',\n",
       " '__doc__',\n",
       " '__eq__',\n",
       " '__format__',\n",
       " '__ge__',\n",
       " '__getattribute__',\n",
       " '__gt__',\n",
       " '__hash__',\n",
       " '__init__',\n",
       " '__init_subclass__',\n",
       " '__le__',\n",
       " '__lt__',\n",
       " '__module__',\n",
       " '__ne__',\n",
       " '__new__',\n",
       " '__reduce__',\n",
       " '__reduce_ex__',\n",
       " '__repr__',\n",
       " '__setattr__',\n",
       " '__sizeof__',\n",
       " '__str__',\n",
       " '__subclasshook__',\n",
       " '__weakref__',\n",
       " 'display',\n",
       " 'setdata']"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# dir(X)\n",
    "dir(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "x.setdata(\"King Arthur\") # Call methods: self is x\n",
    "y.setdata(3.14159)      # Runs: FirstClass.setdata(y, 3.14159)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在 FirstClass 的 setdata 函数中，传入的值会赋给 self.data。在方法中，**self** 会自动引用正在处理的实例（x 或 y）。所以赋值语句会把值存储在实例的命名空间中，而不是类的命名空间中。注意：self 不是 Python 中的保留字，可以被替换为其它的名称，但是约定俗成使用 self 作为参数名。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "因为类会产生很多实例，方法必须经过 self 参数才能获取正在处理的实例。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "King Arthur\n",
      "3.14159\n"
     ]
    }
   ],
   "source": [
    "x.display()     # self.data differs in each instance\n",
    "y.display()     # Runs: FirstClass.display(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "可以看出，每个实例内的 data 成员存储了不同对象类型（字符串和浮点数）。\n",
    "\n",
    "如果在调用 setdata 之前，就对实例调用 display，则会触发未定义变量名的错误。data 属性在 setdata 方法赋值之前，是不会在内存中存在的。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 修改实例属性\n",
    "\n",
    "在类内部，通过方法对属性进行赋值运算；而在类外，则可以通过对实例对象进行赋值运算。我们也可以在类的外部修改实例属性。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "New value\n"
     ]
    }
   ],
   "source": [
    "x.data = \"New value\" # Can get/set attributes\n",
    "x.display()         # Outside the class too"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们甚至可以在实例命名空间内产生全新的属性（用法比较少见）："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "x.anothername = \"spam\" # Can set new attributes here too!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['__class__',\n",
       " '__delattr__',\n",
       " '__dict__',\n",
       " '__dir__',\n",
       " '__doc__',\n",
       " '__eq__',\n",
       " '__format__',\n",
       " '__ge__',\n",
       " '__getattribute__',\n",
       " '__gt__',\n",
       " '__hash__',\n",
       " '__init__',\n",
       " '__init_subclass__',\n",
       " '__le__',\n",
       " '__lt__',\n",
       " '__module__',\n",
       " '__ne__',\n",
       " '__new__',\n",
       " '__reduce__',\n",
       " '__reduce_ex__',\n",
       " '__repr__',\n",
       " '__setattr__',\n",
       " '__sizeof__',\n",
       " '__str__',\n",
       " '__subclasshook__',\n",
       " '__weakref__',\n",
       " 'anothername',\n",
       " 'data',\n",
       " 'display',\n",
       " 'setdata']"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dir(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['__class__',\n",
       " '__delattr__',\n",
       " '__dict__',\n",
       " '__dir__',\n",
       " '__doc__',\n",
       " '__eq__',\n",
       " '__format__',\n",
       " '__ge__',\n",
       " '__getattribute__',\n",
       " '__gt__',\n",
       " '__hash__',\n",
       " '__init__',\n",
       " '__init_subclass__',\n",
       " '__le__',\n",
       " '__lt__',\n",
       " '__module__',\n",
       " '__ne__',\n",
       " '__new__',\n",
       " '__reduce__',\n",
       " '__reduce_ex__',\n",
       " '__repr__',\n",
       " '__setattr__',\n",
       " '__sizeof__',\n",
       " '__str__',\n",
       " '__subclasshook__',\n",
       " '__weakref__',\n",
       " 'data',\n",
       " 'display',\n",
       " 'setdata']"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dir(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2. 类通过继承进行定制\n",
    "\n",
    "除了生成多个实例对象之外，类也可以引入 **子类** 来进行修改，而不对现有组件进行原地的修改。Python 可以让类继承其他类，从而开启了编写**类层次**结构的大门。在这里和模块不一致：模块的属性存在于一个单一的、不接受定制化的命名空间之内。\n",
    "\n",
    "Python中，类继承于**超类**(superclass)，以下是属性继承机制的核心观点；\n",
    "\n",
    "- 超类列在了类开头的括号中\n",
    "      要继承另一个类的属性，把该类列在 class 语句开头的括号中就可以了。\n",
    "\n",
    "- 类从其超类中继承属性\n",
    "      类会继承其超类中定义的所有属性名称。当读取属性时，如果它不存在于子类中，Python 会自动搜索这个属性。\n",
    "\n",
    "- 实例会继承所有可读取类的属性\n",
    "      每个实例不仅会从创建它的类中获取变量名，还会从该类的超类中获取。寻找变量名时，Python 会依次检查实例、它的类以及所有超类。\n",
    "\n",
    "- 每个 object.attribute 都会开启新的独立搜索\n",
    "      Python 会对每个属性取出表达式进行对类树的独立搜索。\n",
    "\n",
    "- 逻辑的修改是通过创建子类，而不是修改超类\n",
    "      在树中层次低的子类中重新定义超类的变量名，子类就可以取代并定制所继承的行为。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.1 第二个例子\n",
    "\n",
    "第二个例子建立在上一个例子基础之上。我们会定义一个新的类 SecondClass，继承 FirstClass 所有变量名，并提供其自己的一个变量名。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "code_folding": []
   },
   "outputs": [],
   "source": [
    "class SecondClass(FirstClass): # Inherits setdata\n",
    "    def display(self): # Changes display\n",
    "        print('Current value = \"{}\"'.format(self.data))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "定义一个和 FirstClass 中属性同名的属性，SecondClass 有效地 **取代/重载**(override) 其超类中的 display 属性。SecondClass 定义 display 方法以不同格式的打印。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Current value = \"42\"\n"
     ]
    }
   ],
   "source": [
    "z = SecondClass()\n",
    "z.setdata(42)       # Finds setdata in FirstClass\n",
    "z.display()         # Finds overridden method in SecondClass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们调用 SecondClass 创建了其实例对象。setdata 依然是执行 FirstClass 中的版本，但是这一次 display 属性是来自 SecondClass。下图是所涉及的命名空间。\n",
    "\n",
    "![img](images/chapter07/override.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "需要留意的是：SecondClass 引入的专有化完全是在 FirstClass 外部完成的，不会影响当前或未来的 FirstClass 对象。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "New value\n"
     ]
    }
   ],
   "source": [
    "x.display()         # x is still a FirstClass instance (old message)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.2 类是模块内的属性\n",
    "\n",
    "在继续学习之前，请记住类的名称并没有什么神奇之处。就像其它一切对象一样，类名称总是存在于模块中。每个模块可以任意混合任意数量的变量、函数以及类，而模块内的所有变量名的行为都相同。\n",
    "\n",
    "例如，某个文件示范如下：\n",
    "\n",
    "```python\n",
    "# food.py\n",
    "var = 1      # food.var\n",
    "def func():  # food.func\n",
    "    ...\n",
    "class spam:  # food.spam\n",
    "    ...\n",
    "class ham:   # food.ham\n",
    "    ...\n",
    "class eggs:  # food.eggs\n",
    "    ...\n",
    "```\n",
    "\n",
    "如果模块和类碰巧有相同的名称，例如文件 person.py 中包含 person 类\n",
    "```python\n",
    "class person:\n",
    "    ...\n",
    "```\n",
    "\n",
    "需要像往常一样通过模块获取类：\n",
    "```python\n",
    "import person   # Import module\n",
    "x = person.person() # Class within module\n",
    "```\n",
    "\n",
    "虽然这个路径看起来像多余的，但却是必需的：person.person 指的是 person 模块内的 person 类。只写 person 只会取得模块，而不是类，除非使用 from 语句。\n",
    "```python\n",
    "from person import person # Get class from module\n",
    "x = person()     # Use class name\n",
    "```\n",
    "\n",
    "如果这看起来令人困惑，就别让模块和该模块内的类使用相同名称。实际上，Python 中的通用惯例是类名应该以**大写字母**开头，以便它们更为清晰：\n",
    "```python\n",
    "import person       # Lowercase for modules\n",
    "x = person.Person() # Uppercase for classes\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3. 类可以截获 Python 运算符\n",
    "\n",
    "现在我们来看看类和模块的第三个主要差别：**运算符重载**。运算符重载是让类的对象可截获并响应应用在内置类型上的运算：加法、切片、打印和点号运算等。\n",
    "\n",
    "虽然我们也可以用方法函数来实现类行为，但运算符重载则让对象和 Python 对象模型更紧密结合起来。此外，因为运算符重载让我们自己定义的对象行为就像内置对象那样，这可以促进对象接口更为一致更易于学习。\n",
    "\n",
    "- 以双下划线命名的方法 (\\_\\_X\\_\\_)是特殊钩子\n",
    "      Python 运算符重载是通过提供特殊命名的方法来实现的。\n",
    "\n",
    "- 当实例出现在内置运算时，这类方法会被自动调用\n",
    "      例如，如果实例对象继承了__add__方法， 当对象出现在 + 表达式内时，该方法就会被调用。\n",
    "\n",
    "- 类可覆盖多数内置类型运算\n",
    "      有几十种特殊运算符重载的方法名称，你几乎可以截获并实现内置类型的所有运算。\n",
    "\n",
    "- 运算符覆盖方法没有默认值\n",
    "      如果类没有定义或继承运算符重载方法，例如没有__add__，+ 表达式就会引发异常。\n",
    "\n",
    "- 运算符可让类与 Python 的对象模型相集成\n",
    "      重载类型运算时，用户定义的类的对象的行为就会像内置对象一样。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.1 第三个例子\n",
    "\n",
    "这次，我们定义 SecondClass 的子类，实现三个特殊名称的属性，让 Python 自动进行调用。\n",
    "\n",
    "- 当新的实例构造时，会调用 **\\_\\_init\\_\\_**\n",
    "\n",
    "\n",
    "- 当 ThirdClass 实例出现在 + 表达式中时，会调用 **\\_\\_add\\_\\_**\n",
    "\n",
    "\n",
    "- 当打印一个对象的时候，运行 **\\_\\_str\\_\\_**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ThirdClass(SecondClass): # Inherit from SecondClass\n",
    "    def __init__(self, value): # On \"ThirdClass(value)\"\n",
    "        print('init {}'.format(value))\n",
    "        self.data = value\n",
    "        \n",
    "    def __str__(self):      # On \"print(self)\", \"str()\"\n",
    "        return '[ThirdClass: %s]' % self.data\n",
    "    \n",
    "    def __add__(self, other): # On \"self + other\"\n",
    "        return ThirdClass(self.data + other)    \n",
    "    \n",
    "    def mul(self, other): # In-place change: named\n",
    "        self.data *= other"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "init cnu\n"
     ]
    }
   ],
   "source": [
    "a = ThirdClass('cnu') # __init__ called"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ThirdClass 是 SecondClass 的子类，所以其实例会继承 SecondClass 的 display 方法。但是，ThirdClass 生成的调用现在需要传递一个参数（例如\"cnu\"），这是传给 \\_\\_init\\_\\_ 构造函数内的参数 value 的。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# a_error = ThirdClass() # missing 1 required positional argument"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Current value = \"cnu\"\n"
     ]
    }
   ],
   "source": [
    "a.display()         # Inherited method called"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "此外，ThirdClass 对象现在可以出现在 + 表达式和 print 调用中。\n",
    "\n",
    "对于 +，Python 把左侧的实例对象传给 \\_\\_add\\_\\_ 中的 self 参数，而把右边的值传给 other。\n",
    "\n",
    "对于 print，Python 把要打印的对象传递给 \\_\\_str\\_\\_ 中的 self，该方法返回的字符串可以看作是对象的打印字符串。\n",
    "\n",
    "注意 \\_\\_add\\_\\_ 方法创建并返回这个类的新的实例对象。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ThirdClass: cnu]\n"
     ]
    }
   ],
   "source": [
    "print(a)            # __str__: returns display string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "init cnu_math\n"
     ]
    }
   ],
   "source": [
    "b = a + '_math'     # __add__: makes a new instance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Current value = \"cnu_math\"\n"
     ]
    }
   ],
   "source": [
    "b.display()         # b has all ThirdClass methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ThirdClass: cnu_math]\n"
     ]
    }
   ],
   "source": [
    "print(b)            # __str__: returns display string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ThirdClass: cnucnucnu]\n"
     ]
    }
   ],
   "source": [
    "a.mul(3)            # mul: changes instance in place\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "运算符重载方法的名称并不是内置变量或者保留字，只是当对象出现在不同的环境时 Python 会去搜索的属性。\n",
    "\n",
    "虽然可以在自己的类中以任何喜欢的方式解释运算符，但是通常的实践说明：重载的运算符应该与内置的运算符实现同样的方式工作，"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.2 为什么要使用运算符重载\n",
    "\n",
    "作为类的设计者，你可以选择使用或者不使用运算符重载。你的抉择取决于有多想让对象的用法和外观**看起来更像内置类型**。如果省略运算符重载方法，实例就不支持相应的运算，如果试着使用这个实例进行运算，就会抛出异常。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "不同的类对于运算符重载的需求也不同。本质为数学的对象，会用到许多运算符重载方法。例如，向量或矩阵类可以重载加法运算符。但员工类可能就不用。更简单的类，可能根本不会用到重载。\n",
    "\n",
    "另外，如果传递定义的类对象给内置类型（例如字典或列表）可用的运算符的函数，可能就需要使用运算符重载。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<font color = blue>几乎每个实际的类都会出现的一个重载方法是 \\_\\_init\\_\\_ 构造函数。</font>因为这可以让类立即在其新建的实例内添加属性。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 4. 最简单的 Python 类"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "下列语句建立一个类，其内完全没有附加的属性。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "class rec:    # Empty namespace object\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4.1 在 class 语句外增加属性"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "建立这个类后，就可以完全在最初的 class 语句外，通过赋值变量名给这个类增加属性："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "rec.name = 'Bob' # Just objects with attributes\n",
    "rec.age = 40"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "通过赋值语句创建这些属性后，就可以用一般的语法将它们取出。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bob\n"
     ]
    }
   ],
   "source": [
    "print(rec.name) # Like a C struct or a record"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "上面的做法没有任何问题，即使该类还没有实例。事实上，类只是**独立完备的命名空间**，只要有类的引用值，就可以在任何时刻设定或修改其属性。\n",
    "\n",
    "现在，我们建立两个实例："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = rec()       # Instances inherit class names\n",
    "y = rec()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "目前这些实例完全是空的命名空间对象，不过因为它们知道创建它们的类，所以会继承并获取附加在类上的属性。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bob Bob\n"
     ]
    }
   ],
   "source": [
    "# name is stored on the class only\n",
    "print(x.name, y.name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "其实这些实例本身没有属性，它们只是从类对象那里取出 name 属性。不过，如果把一个属性赋值给一个实例，就会在该对象内部 **创建**（或修改）该属性。\n",
    "\n",
    "**属性赋值运算只会影响属性赋值所在的对象，而不会因属性的引用而启动继承搜索。**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('Bob', 'Sue', 'Bob')"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Assignment changes x only\n",
    "x.name = 'Sue'\n",
    "rec.name, x.name, y.name"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\\_\\_dict\\_\\_ 属性是针对大多数基于类的对象的命名空间字典（一些类也可能在 \\_\\_slots\\_\\_ 中定义属性）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['__module__', '__dict__', '__weakref__', '__doc__', 'name', 'age']"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(rec.__dict__.keys())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['name', 'age']"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(name for name in rec.__dict__ if not name.startswith('__'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['name']"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(x.__dict__.keys())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(y.__dict__.keys())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在这里，类的字典显示出我们进行赋值了的 name 和 age 属性，x 有自己的 name，而 y 的字典依然是空的。\n",
    "\n",
    "可以使用 \\_\\_class\\_\\_ 显示每个实例所属的类："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "__main__.rec"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.__class__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "类也有一个 \\_\\_bases\\_\\_ 属性（实例没有这个属性），它是一个由其超类构成的元组。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(object,)"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rec.__bases__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python 中的类模型非常动态。类和实例只是命名空间对象，属性是通过赋值语句动态建立的，只是默认赋值语句往往在 class 语句内。**即使是方法**（通常是在类中通过 def 创建）也可以在任意类对象的外部创建。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "def uppername(obj):\n",
    "    return obj.name.upper() # Still needs a self argument (obj)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这个简单函数暂时和类完全没有什么关系。只要我们传一个带有 name 属性的对象就可以调用："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'SUE'"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Call as a simple function\n",
    "uppername(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "不过，如果我们把这个简单函数赋值成类的属性，它就会变成方法，可以被该类的任何实例调用，也可以通过类名称本身调用（只要我们手动传入一个实例）。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Now it's a class's method!\n",
    "rec.method = uppername"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'SUE'"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.method() # Run method to process x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'SUE'"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Can call through instance or class\n",
    "rec.method(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "通常情况下，类的定义都在 class 语句块中，实例的属性是通过在方法函数内对 self 属性进行赋值运算而创建的。 但是，从上面的例子也可看出，并不是必须如此。Python 中的 OOP 其实就是**在已连接的命名空间对象中寻找属性**而已。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4.2 类与字典的关系\n",
    "\n",
    "基于字典的记录示例如下："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "rec = {}\n",
    "rec['name'] = 'Bob'   # Dictionary-based record\n",
    "rec['age'] = 40.5     # Or {...}, dict(n=v), etc.\n",
    "rec['jobs'] = ['dev', 'mgr']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bob\n"
     ]
    }
   ],
   "source": [
    "print(rec['name'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "下面代码使用类实现同样功能，语法比起字典要简洁很多。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "code_folding": []
   },
   "outputs": [],
   "source": [
    "class rec:\n",
    "    pass\n",
    "\n",
    "rec.name = 'Bob'    # Class-based record\n",
    "rec.age = 40.5\n",
    "rec.jobs = ['dev', 'mgr']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bob\n"
     ]
    }
   ],
   "source": [
    "print(rec.name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "它使用一个空的 class 语句来产生一个空的命名空间对象。一旦我们产生了空类，就可以随时向其中赋值类属性。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们也可以产生一个空类的实例，来表示每条不同的记录。这次有两个分开的实例对象，因此有两个不同的 name 属性。另外，同一个类的多个实例甚至可以具有不同的属性名称。在下面这个例子中，pers1 有唯一的 age 属性名称。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "code_folding": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('Bob', 'Sue')"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class rec:\n",
    "    pass\n",
    "\n",
    "# Instance-based records\n",
    "pers1 = rec()\n",
    "pers1.name = 'Bob'\n",
    "pers1.jobs = ['dev', 'mgr']\n",
    "pers1.age = 40.5\n",
    "\n",
    "pers2 = rec()\n",
    "pers2.name = 'Sue'\n",
    "pers2.jobs = ['dev', 'cto']\n",
    "\n",
    "pers1.name, pers2.name"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "实例实际上是不同的名称空间，因此，每个实例都有一个不同的属性字典。尽管它们通常由类方法一致地填充，但它们比我们预期的更加灵活。\n",
    "\n",
    "最后，我们可以编写一个更完整的类来实现记录："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Person:\n",
    "    def __init__(self, name, jobs, age=None): # class = data + logic\n",
    "        self.name = name\n",
    "        self.jobs = jobs\n",
    "        self.age = age\n",
    "    def info(self):\n",
    "        return (self.name, self.jobs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Construction calls\n",
    "rec1 = Person('Bob', ['dev', 'mgr'], 40.5)\n",
    "rec2 = Person('Sue', ['dev', 'cto'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['dev', 'mgr']\n",
      "('Sue', ['dev', 'cto'])\n"
     ]
    }
   ],
   "source": [
    "# Attributes\n",
    "print(rec1.jobs)\n",
    "# Methods\n",
    "print(rec2.info())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这段代码也产生了多个实例，但是这次类不是空类。我们在类中添加了方法，类的构造函数强制了所有实例都必须设置 name 和 job 属性。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "最后，尽管像字典这样的内置类型是非常灵活的（甚至可以将函数存储到字典中），但类允许我们为对象添加行为。所以，对于处理隐含的实例，没有比类更加自然的对象了。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 5. 实际的例子\n",
    "\n",
    "通常掌握 Python 类的语法很容易，但是当面对实际问题时，要搞清楚如何下手还是有麻烦。\n",
    "\n",
    "因此，在本节中将编写两个类，通过逐渐地构筑类，以便看到其功能如何组合到一个完整的程序中，并最后测试它们的功能：\n",
    "\n",
    "- Person - 处理关于人员信息的类\n",
    "- Manager - 一个特殊的 Person，修改了继承的行为\n",
    "\n",
    "虽然类所使用的代码较少，但是它们将展示 Python 的 OOP 模型的所有主要思想。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 步骤1：创建实例\n",
    "\n",
    "在 Python 惯例中，模块名使用小写字母开头，而类名使用一个大写字母开头。因此，我们将新的模块文件命名为 person.py，将其中的类命名为 Person。\n",
    "\n",
    "我们要做的第一件事就是记录人员的基本信息，这些是实例对象属性，它们是通过给类方法函数中的 self 属性赋值来创建。通常在 \\_\\_init\\_\\_ 构造函数中赋给实例属性初值。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Add record field initialization\n",
    "\n",
    "class Person:\n",
    "    def __init__(self, name, job, pay): # Constructor takes three arguments\n",
    "        self.name = name    # Fill out fields when created\n",
    "        self.job = job      # self is the new instance object\n",
    "        self.pay = pay"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在面向对象中，self 就是新创建的实例对象，name, job 和 pay 变成了状态信息，即保存在对象中供随后使用的描述性数据。self 参数由 Python 自动填充以引用实例对象，将值赋给 self 属性就会将值赋给新的实例。\n",
    "\n",
    "作为示例，我们可以让 job 参数成为可选的参数，它将默认为 None，这意味着所创建的人目前没有工作。同时为了一致性也希望默认的 pay 为 0。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Add defaults for constructor arguments\n",
    "\n",
    "class Person:\n",
    "    def __init__(self, name, job=None, pay=0): # Normal function args\n",
    "        self.name = name\n",
    "        self.job = job\n",
    "        self.pay = pay"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这段代码意味着当我们创建 Person 时，需要给 name 传入值，但是 job 和 pay 是可选的。\n",
    "\n",
    "这个类目前还没有做太多事情，它基本上只是填充了一条新纪录的字段，但是它确实是一个有效的类。在添加更多功能之前，让我们先来测试目前的代码：生成类的实例并且显示它们的属性。可以通过交互式提示进行简单一次性的测试，也可以通过在文件底部编写代码来进行更多的测试。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bob Smith 0\n",
      "Sue Jones 100000\n"
     ]
    }
   ],
   "source": [
    "# Add incremental self-test code\n",
    "\n",
    "class Person:\n",
    "    def __init__(self, name, job=None, pay=0):\n",
    "        self.name = name\n",
    "        self.job = job\n",
    "        self.pay = pay\n",
    "        \n",
    "bob = Person('Bob Smith') # Test the class\n",
    "sue = Person('Sue Jones', job='dev', pay=100000) # Runs __init__ automatically\n",
    "print(bob.name, bob.pay) # Fetch attached attributes\n",
    "print(sue.name, sue.pay) # sue's and bob's attrs differ"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "从技术上讲，Bob 和 Sue 都是独立的命名空间对象(namespace object)，它们都拥有各自类所创建的状态信息的独立副本。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "文件底部的测试代码有个问题：当文件作为脚本运行时或者它作为一个模块导入时，它的顶层的 print 语句都会运行。这不是一种好的软件关系，因为客户端程序并不关心我们内部的测试，也不希望我们的测试输出和它们的输出混合到一起。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bob Smith 0\n",
      "Sue Jones 100000\n"
     ]
    }
   ],
   "source": [
    "# Allow this file to be imported as well as run/tested\n",
    "\n",
    "class Person:\n",
    "    def __init__(self, name, job=None, pay=0):\n",
    "        self.name = name\n",
    "        self.job = job\n",
    "        self.pay = pay\n",
    "\n",
    "if __name__ == '__main__': # When run for testing only\n",
    "    # self-test code\n",
    "    bob = Person('Bob Smith')\n",
    "    sue = Person('Sue Jones', job='dev', pay=100000)\n",
    "    print(bob.name, bob.pay)\n",
    "    print(sue.name, sue.pay)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 步骤2：添加行为方法\n",
    "\n",
    "目前，我们的类基本上是一个记录工厂，它创建并填充了记录的字段。即便有些局限性，但我们仍然可以在其对象上运行某些操作。\n",
    "\n",
    "例如，对象的 name 字段只是一个简单的字符串，因此我们可以通过使用字符串的 split() 方法从对象提取姓氏。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Bob', 'Smith']"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "name = 'Bob Smith' # Simple string, outside class\n",
    "name.split()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Smith'"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "name.split()[-1] # Or [1], if always just two parts"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "也可以通过赋值来修改对象的 pay 字段来增加工资："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bob Smith 0\n",
      "Smith\n",
      "Sue Jones 100000\n",
      "110000.00\n"
     ]
    }
   ],
   "source": [
    "# Process embedded built-in types: strings, mutability\n",
    "\n",
    "class Person:\n",
    "    def __init__(self, name, job=None, pay=0):\n",
    "        self.name = name\n",
    "        self.job = job\n",
    "        self.pay = pay\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    bob = Person('Bob Smith')\n",
    "    sue = Person('Sue Jones', job='dev', pay=100000)\n",
    "    print(bob.name, bob.pay)\n",
    "    print(bob.name.split()[-1]) # Extract object's last name\n",
    "    print(sue.name, sue.pay)\n",
    "    sue.pay *= 1.10 # Give this object a raise\n",
    "    print('%.2f' % sue.pay)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "上面的代码可以按照计划工作，但是像这样在类外的硬编码操作会导致未来的维护问题。例如，如果你已经在程序中的很多地方硬编码了姓氏提取操作，此时你需要改变其工作方式（例如，为了支持一种新的名字结构），你将需要查找这段代码出现的所有地方并逐一进行更新。与此类似，如果涨工资代码发生变化（例如需要更新数据库），你可能需要多个地方都需要修改。在较大的程序中，光是找到这些代码出现的所有地方就成问题，它们可能位于多个文件中。\n",
    "\n",
    "这里，我们要提出 <font color=blue>**封装**</font> 的软件设计概念。封装的思想就是把操作逻辑包装到界面之后，这样每种操作在我们的程序中只编码一次。通过这种方式，如果将来需要修改，只需要修改一个版本。\n",
    "\n",
    "用 Python 术语来说，我们想要操作对象的代码位于类方法中，而不是分散在整个程序中。这样还会使得这些操作可以应用于类的任何实例，而不是仅能应用于把它们硬编码来处理的那些对象。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bob Smith 0\n",
      "Smith Jones\n",
      "Sue Jones 100000\n",
      "110000\n"
     ]
    }
   ],
   "source": [
    "# Add methods to encapsulate operations for maintainability\n",
    "\n",
    "class Person:\n",
    "    def __init__(self, name, job=None, pay=0):\n",
    "        self.name = name\n",
    "        self.job = job\n",
    "        self.pay = pay\n",
    "        \n",
    "    def lastName(self): # Behavior methods\n",
    "        return self.name.split()[-1] # self is implied subject\n",
    "    \n",
    "    def giveRaise(self, percent):\n",
    "        self.pay = int(self.pay * (1 + percent)) # Must change here only\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    bob = Person('Bob Smith')\n",
    "    sue = Person('Sue Jones', job='dev', pay=100000)\n",
    "    print(bob.name, bob.pay)\n",
    "    print(bob.lastName(), sue.lastName()) # Use the new methods\n",
    "    print(sue.name, sue.pay)\n",
    "    sue.giveRaise(.10) # instead of hardcoding\n",
    "    print(sue.pay)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python 通过自动把实例传递给第一个参数，从而告诉一个方法应该处理哪个实例，通常这个参数叫做 self。特别是：\n",
    "\n",
    "- 在调用 bob.lastName() 时，bob 是隐藏的主体，传递给了 self\n",
    "- 在调用 sue.lastName() 时，sue 是隐藏的主体，传递给了 self"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 步骤3：运算符重载\n",
    "\n",
    "实例对象的默认显示格式并不太友好，它只显示对象的类名以及其在内存中的地址。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<__main__.Person object at 0x000002011ABFF2B0>\n"
     ]
    }
   ],
   "source": [
    "bob = Person('Bob Smith')\n",
    "print(bob)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们可以通过**运算符重载**的方式，在类中编写这样一个方法，当方法在类的实例运行的时候，方法截获并处理内置的操作。每个实例在转换为打印字符串时，\\_\\_str\\_\\_ 方法在都会自动运行。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Person: Bob Smith, 0]\n",
      "[Person: Sue Jones, 100000]\n",
      "Smith Jones\n",
      "[Person: Sue Jones, 110000]\n"
     ]
    }
   ],
   "source": [
    "# Add __str__ overload method for printing objects\n",
    "\n",
    "class Person:\n",
    "    def __init__(self, name, job=None, pay=0):\n",
    "        self.name = name\n",
    "        self.job = job\n",
    "        self.pay = pay\n",
    "    def lastName(self):\n",
    "        return self.name.split()[-1]\n",
    "    def giveRaise(self, percent):\n",
    "        self.pay = int(self.pay * (1 + percent))\n",
    "    def __str__(self):           # Added method\n",
    "        return '[Person: {}, {}]'.format(self.name, self.pay) # String to print\n",
    "\n",
    "if __name__ == '__main__':\n",
    "    bob = Person('Bob Smith')\n",
    "    sue = Person('Sue Jones', job='dev', pay=100000)\n",
    "    print(bob)\n",
    "    print(sue)\n",
    "    print(bob.lastName(), sue.lastName())\n",
    "    sue.giveRaise(.10)\n",
    "    print(sue)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "所有关于内置类型和函数的内容都适用于基于类的代码。类很大程度上只是添加了额外的一层结构，它将函数和数据包装在一起并支持扩展。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 步骤4：通过子类定制行为\n",
    "\n",
    "现在我们的类已经具备了大多数 OOP 机制：创建实例，在方法中提供行为，并且做了运算符重载来改变打印操作。它有效地把数据和逻辑一起包装到一个单个的自包含的软件组件中，使得将来能够定位代码并很直接地修改代码。通过封装行为，它可以避免代码冗余构建和难以维护。\n",
    "\n",
    "它还未涉及的一个重要 OOP 概念是通过**继承**来定制化：基于已完成工作的定制行为，这种编码模式可以显著地缩减开发时间。要展示 OOP 的真正的能力，我们需要定义一个超类/子类关系，以允许我们扩展并替代继承的行为。\n",
    "\n",
    "我们定义 Person 的一个子类，名为 Manager，它用一个特殊的版本替代了继承的 giveRaise 方法。我们假设当一个 Manager 要涨工资的时候，它像往常一样接受一个百分比，同时也会获得一份默认10%的额外奖金。\n",
    "\n",
    "```python\n",
    "class Manager(Person): # Inherit Person attrs\n",
    "    def giveRaise(self, percent, bonus=.10): # Redefine to customize\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 不好的方式\n",
    "\n",
    "不好的方式是复制粘贴 Person 中的 giveRaise 代码，然后针对 Manager 进行修改："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Manager(Person):\n",
    "    def giveRaise(self, percent, bonus=.10):\n",
    "        # Bad: cut and paste\n",
    "        self.pay = int(self.pay * (1 + percent + bonus))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这里的问题是一个非常常见的问题。考虑一下：因为我们复制了最初的版本，如果一旦改变了涨工资的方式，我们必须同时修改这两个地方的代码。尽管这是一个刻意设计的例子，但它代表了一个广泛的问题。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 较好的方式\n",
    "\n",
    "我们这里真正想要做的事情是扩展最初的 giveRaise，而不是完全替换它。因此我们使用修改的参数来直接调用其最初的版本："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Manager(Person):\n",
    "    def giveRaise(self, percent, bonus=.10):\n",
    "        # Good: augment original\n",
    "        Person.giveRaise(self, percent + bonus)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这段代码展示了这样的语法：类方法总是可以在**实例**中调用（这也是通常的方法，Python 将该实例自动发送给 self 参数），也可以通过**类**来调用（较少见的方式，我们必须手动地传递实例）。不管哪种方式，调用非静态的类方法总是需要一个主体实例。\n",
    "\n",
    "- 常规调用\n",
    "      instance.method(args...)\n",
    "\n",
    "- 同等形式\n",
    "      class.method(instance, args...)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在这个例子中，我们可以在子类中直接调用超类中默认的 giveRaise 方法，即便该方法已经在 Manager 类中重新定义了。我们也必须按照这种方式来调用，因为如果 Manager 的 giveRaise 代码内部如果调用 self.giveRaise() 会导致<font color=red>死循环</font>，直到可用内存耗尽程序崩溃。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "两种实现方式在代码上略有不同，但是好的方式会对未来的**代码维护**意义重大。将来需要修改的时候，我们只需要修改一个版本。实际上，这种形式更加符合我们的本意——我们想要执行标准的 giveRaise 操作，但直接加上一个额外的奖金。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "为了测试这个 Manager 子类定制，我们添加了测试代码："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Person: Tom Jones, 50000]\n",
      "Jones\n",
      "[Person: Tom Jones, 60000]\n"
     ]
    }
   ],
   "source": [
    "# Create a Manager: __init__\n",
    "tom = Manager('Tom Jones', 'mgr', 50000)\n",
    "print(tom)          # Runs inherited __str__\n",
    "print(tom.lastName()) # Runs inherited method\n",
    "tom.giveRaise(.10)  # Runs custom version\n",
    "print(tom)          # Runs inherited __str__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "从这段代码也可以看出，Manager 对象自动从 Person 继承了 \\_\\_init\\_\\_、lastName 和 \\_\\_str\\_\\_ 方法。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### OOP(Object Oriented Programming) 思想\n",
    "\n",
    "虽然我们的代码很小，但是它功能完备，并且能够说明 OOP 背后一般性的要点：通过**定制**(customizing)来编程，而不是复制和修改已有的代码。\n",
    "\n",
    "- 尽管我们可以**从头开始**编写 Manager 全新的、独立的代码，但必须重新实现 Person 中所有那些与 Manager 相同的行为\n",
    "\n",
    "\n",
    "- 尽管我们可以**直接原处修改**已有的 Person 类来满足 Manager 的需求，但这么做可能会使需要原来的 Person 行为的地方无法满足需求。\n",
    "\n",
    "\n",
    "- 尽管我们可以直接完整地**复制** Person 类，将副本重命名为 Manager，再修改其 giveRaise。复制粘贴的方法可能看上去很快，但这么做将会引入代码冗余，会使将来的工作倍增——未来对 Person 的修改，往往需要手动地在 Manager 的代码中修改。\n",
    "\n",
    "我们可以用类来构建**可定制层级结构**，通过编写新的子类来裁剪或扩展之前的工作，为那些将会随时间发展的软件提供一个更好的解决方案。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 步骤5：定制构造函数\n",
    "\n",
    "之前的版本，我们在创建 Manager 对象时，必须为它提供一个 mgr 工作名称，这似乎是没有意义的，因为类自身已经暗示了。更好的实现方式是在创建 Manager 的时候，以某种方式自动填入这个值。\n",
    "\n",
    "因此，我们想重新定义 Manager 中的 \\_\\_init\\_\\_ 方法，从而提供 mgr 字符串。而且和 giveRaise 的定制类似，我们想通过类名的调用来运行超类中的 \\_\\_init\\_\\_ 方法，以便它仍然会初始化对象的状态信息属性。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Manager(Person):\n",
    "    # Redefine constructor\n",
    "    def __init__(self, name, pay):\n",
    "        # Run original with 'mgr'\n",
    "        Person.__init__(self, name, 'mgr', pay)\n",
    "    def giveRaise(self, percent, bonus=.10):\n",
    "        Person.giveRaise(self, percent + bonus)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Person: Tom Jones, 50000]\n"
     ]
    }
   ],
   "source": [
    "tom = Manager('Tom Jones', 50000) # Job name not needed\n",
    "print(tom)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这里我们同样通过类名直接调用并显示传递 self 实例，从而运行超类的版本。如果不运行超类的构造函数，实例就不会附加任何的属性。\n",
    "\n",
    "以这种重定义的方式调用超类构造函数，在 Python 中是一种很常见的编码模式。你可以明确指出哪些参数传递给超类的构造函数，也可以选择根本不调用它。不调用超类的构造函数允许你整个**替代**超类逻辑，而不是**扩展**它。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 步骤6：使用内省(Introspection)工具\n",
    "\n",
    "内省是指计算机程序在运行时(Run time)检查对象类型的一种能力，通常也可以称作运行时类型检查。\n",
    "\n",
    "现在我们的类是完整的，并且展示了 Python 中大多数基本的 OOP。然而，它仍然有两个问题，我们应该在使用对象之前解决这两个问题：\n",
    "\n",
    "- 首先，如果查看对象的显示，当打印 tom 的时候，输出信息仍然是 Person 而不是 Manager。我们应该尽可能用最确切的类来显示对象。\n",
    "\n",
    "\n",
    "- 其次，当前的显示格式只是显示了包含在 \\_\\_str\\_\\_ 中的属性，没有考虑未来可能添加的属性。如果我们改变或者修改了在 \\_\\_init\\_\\_ 中分配给对象的属性集合，那么还必须也要更新 \\_\\_str\\_\\_ 以显示新的名字，否则将无法随着时间的推移而同步。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们可以使用 Python 的**内省工具**来解决这两个问题，它们是特殊的属性和函数，允许我们访问对象实现的一些内部机制。这些工具较为高级，并且为其他程序员编写工具的人比开发应用程序的人更为广泛使用它们。\n",
    "\n",
    "- 内置的 instance.\\_\\_class\\_\\_ 属性提供了一个从实例到创建它的类的链接。\n",
    "\n",
    "\n",
    "- 内置的 object.\\_\\_dict\\_\\_ 属性提供了一个字典，字典中的每个键值对都是属性附加到一个命名空间对象。\n",
    "\n",
    "下面是这些工具在交互模式中实际使用的情形："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Person: Bob Smith, 0]\n"
     ]
    }
   ],
   "source": [
    "bob = Person('Bob Smith')\n",
    "print(bob)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "__main__.Person"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bob.__class__  # Show bob's class and its name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Person'"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bob.__class__.__name__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['name', 'job', 'pay']"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(bob.__dict__.keys())    # Attributes are really dict keys"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "name => Bob Smith\n",
      "job => None\n",
      "pay => 0\n"
     ]
    }
   ],
   "source": [
    "for key in bob.__dict__:\n",
    "    print(key, '=>', bob.__dict__[key]) # Index manually"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "name => Bob Smith\n",
      "job => None\n",
      "pay => 0\n"
     ]
    }
   ],
   "source": [
    "for key in bob.__dict__:\n",
    "    print(key, '=>', getattr(bob, key)) # using built-in function: getattr()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 通用显示工具\n",
    "\n",
    "我们实现一个重载了 \\_\\_str\\_\\_ 方法的 AttrDisplay 类，它自动变成一个公用工具：得益于继承，它可以和想使用它显示格式的任何类进行混合。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [],
   "source": [
    "class AttrDisplay:\n",
    "    \"\"\"\n",
    "    Provides an inheritable display overload method that shows\n",
    "    instances with their class names and a name=value pair for\n",
    "    each attribute stored on the instance itself (but not attrs\n",
    "    inherited from its classes). Can be mixed into any class,\n",
    "    and will work on any instance.\n",
    "    \"\"\"\n",
    "    def gatherAttrs(self):\n",
    "        attrs = []\n",
    "        for key in sorted(self.__dict__):\n",
    "            attrs.append('%s=%s' % (key, getattr(self, key)))\n",
    "        return ', '.join(attrs)\n",
    "    def __str__(self):\n",
    "        return '[%s: %s]' % (self.__class__.__name__, self.gatherAttrs())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "然后我们将顶层类 Person 修改为从 AttrDisplay 类继承而来，因此类 Person 和子类 Manager 的实例都会继承新的打印重载方法。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Person(AttrDisplay): # Mix in a repr at this level\n",
    "    \"\"\"\n",
    "    Create and process person records\n",
    "    \"\"\"\n",
    "    def __init__(self, name, job=None, pay=0):\n",
    "        self.name = name\n",
    "        self.job = job\n",
    "        self.pay = pay\n",
    "    def lastName(self): # Assumes last is last\n",
    "        return self.name.split()[-1]\n",
    "    def giveRaise(self, percent): # Percent must be 0..1\n",
    "        self.pay = int(self.pay * (1 + percent))\n",
    "        \n",
    "class Manager(Person):\n",
    "    \"\"\"\n",
    "    A customized Person with special requirements\n",
    "    \"\"\"\n",
    "    def __init__(self, name, pay):\n",
    "        Person.__init__(self, name, 'mgr', pay) # Job name is implied\n",
    "    def giveRaise(self, percent, bonus=.10):\n",
    "        Person.giveRaise(self, percent + bonus)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "现在再运行测试代码，将会输出对象的所有属性，而不只是最初的 \\_\\_str\\_\\_ 中直接编码的那些属性。这正是我们所追求的更有用的显示。\n",
    "\n",
    "从更长远的角度来看，我们的属性显示类 AttrDisplay 已经变成了一个**通用工具**，可以通过继承将其混合到任何类中，从而利用它所定义的显示格式。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Person: job=None, name=Bob Smith, pay=0]\n",
      "[Person: job=dev, name=Sue Jones, pay=100000]\n",
      "Smith Jones\n",
      "[Person: job=dev, name=Sue Jones, pay=110000]\n",
      "Jones\n",
      "[Manager: job=mgr, name=Tom Jones, pay=60000]\n"
     ]
    }
   ],
   "source": [
    "if __name__ == '__main__':\n",
    "    bob = Person('Bob Smith')\n",
    "    sue = Person('Sue Jones', job='dev', pay=100000)\n",
    "    print(bob)\n",
    "    print(sue)\n",
    "    print(bob.lastName(), sue.lastName())\n",
    "    sue.giveRaise(.10)\n",
    "    print(sue)\n",
    "    tom = Manager('Tom Jones', 50000)\n",
    "    tom.giveRaise(.10)\n",
    "    print(tom.lastName())\n",
    "    print(tom)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 步骤7：将对象存储到数据库中\n",
    "\n",
    "此时，我们的工作几乎完成了。但是我们的类创建的对象还不是真正的数据库记录，它们是内存中的临时性对象，如果我们关闭 Python，实例也将消失。因此，未来程序运行的时候，它们不再可用。现在我们要让 **对象持久化**(object persistence)——让对象在创建它们的程序退出之后依然存在。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### pickle 和 shelve\n",
    "\n",
    "对象持久化可以通过两个标准库模块来实现：\n",
    "\n",
    "- pickle（参考 *Chapter04.Tuples_and_files*）\n",
    "      任意 Python 对象和字符串之间的序列化\n",
    "\n",
    "- shelve\n",
    "      按照键将 Python 对象存储到文件中\n",
    "      \n",
    "尽管使用 pickle 将对象存储为简单的普通文件并随后载入它们是很容易的，但 shelve 模块提供了一个额外的层结构，它允许按照键来存储 pickle 处理后的对象。shelve 使用 pickle 将一个对象转换为字符串，并将其存储在文件中的键之下；随后载入时，shelve 通过键获取 pickle 的字符串，并用 pickle 在内存中重新创建最初的对象。\n",
    "\n",
    "一个 shelve 的 pickle 化的对象看上去就像字典——可以通过键索引来访问、指定键来存储并且可以使用 len、in 和 dict.keys 这样的字典工具来获取信息。实际上，shelve 和常规字典之间的唯一区别是：一开始必须**打开** shelve 并且在修改之后必须**关闭**它。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 在 shelve 数据库中存储对象\n",
    "\n",
    "首先，我们创建几个 Person 和 Manager 类的实例。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [],
   "source": [
    "bob = Person('Bob Smith') # Re-create objects to be stored\n",
    "sue = Person('Sue Jones', job='dev', pay=100000)\n",
    "tom = Manager('Tom Jones', 50000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "一旦有了这些实例，就很容易将它们存储到 shelve 中。我们先导入 shelve 模块，打开一个外部文件名，将对象赋给 shelve 中的键，最后在操作完成后关闭这个 sheleve。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [],
   "source": [
    "import shelve\n",
    "\n",
    "# Filename where objects are stored\n",
    "db = shelve.open('persondb')\n",
    "for obj in (bob, sue, tom): # Use object's name attr as key\n",
    "    db[obj.name] = obj      # Store object on shelve by key\n",
    "# Close after making changes\n",
    "db.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "注意是如何将对象的名字用作键，从而把它们赋给 shelve 的。在 shelve 中**键**可以是任何的字符串，我们这么做只是为了方便。唯一的规则是，键必须是字符串并且是唯一的。这样我们就可以针对每个键只存储一个对象。存储在键之下的**值**可以是几乎任何类型的 Python 对象：像字符串、列表和字典这样的内置对象、用户定义的类实例，以及所有这些嵌套式的组合。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "此时，当前目录下会生成多个文件，它们名字都以\"persondb\"开头，它们是二进制 hash 文件，不支持 SQL 这样的查询工具，并且大多数内容对于 shelve 模块以外的环境没有太大意义。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['persondb.bak', 'persondb.dat', 'persondb.dir']"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 文件名模式匹配库\n",
    "import glob\n",
    "glob.glob('persondb*')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "'Bob Smith', (0, 82)\n",
      "'Sue Jones', (512, 94)\n",
      "'Tom Jones', (1024, 93)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(open('persondb.dir').read())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b'\\x80\\x03c__main__\\nPerson\\nq\\x00)\\x81q\\x01}q\\x02(X\\x04\\x00\\x00\\x00nameq\\x03X\\t\\x00\\x00\\x00Bob Smithq\\x04X\\x03\\x00\\x00\\x00jobq\\x05NX\\x03\\x00\\x00\\x00payq\\x06K\\x00ub.\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x80\\x03c__main__\\nPerson\\nq\\x00)\\x81q\\x01}q\\x02(X\\x04\\x00\\x00\\x00nameq\\x03X\\t\\x00\\x00\\x00Sue Jonesq\\x04X\\x03\\x00\\x00\\x00jobq\\x05X\\x03\\x00\\x00\\x00devq\\x06X\\x03\\x00\\x00\\x00payq\\x07J\\xa0\\x86\\x01\\x00ub.\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x80\\x03c__main__\\nManager\\nq\\x00)\\x81q\\x01}q\\x02(X\\x04\\x00\\x00\\x00nameq\\x03X\\t\\x00\\x00\\x00Tom Jonesq\\x04X\\x03\\x00\\x00\\x00jobq\\x05X\\x03\\x00\\x00\\x00mgrq\\x06X\\x03\\x00\\x00\\x00payq\\x07MP\\xc3ub.'\n"
     ]
    }
   ],
   "source": [
    "print(open('persondb.dat', 'rb').read())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "为了验证保存结果，我们可以重新打开保存的数据库文件。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Reopen the shelve\n",
    "db = shelve.open('persondb')\n",
    "len(db)     # Three 'records' stored"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Bob Smith', 'Sue Jones', 'Tom Jones']"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(db.keys())     # keys is the index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Person: job=None, name=Bob Smith, pay=0]\n",
      "<class '__main__.Person'>\n"
     ]
    }
   ],
   "source": [
    "bob = db['Bob Smith'] # Fetch bob by key\n",
    "print(bob)\n",
    "print(type(bob))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Smith'"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bob.lastName()      # Runs lastName from Person"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bob Smith => [Person: job=None, name=Bob Smith, pay=0]\n",
      "Sue Jones => [Person: job=dev, name=Sue Jones, pay=100000]\n",
      "Tom Jones => [Manager: job=mgr, name=Tom Jones, pay=50000]\n"
     ]
    }
   ],
   "source": [
    "for key in db:      # Iterate, fetch, print\n",
    "    print(key, '=>', db[key])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "注意，在这里，为了载入或使用存储的对象，我们不一定必须导入 Person 或 Manager 类。例如，我们可以自由地调用 bob 的 lastName 方法，并且自动获取其定制的打印显示格式，即便在我们的作用域中没有 Person 类。\n",
    "\n",
    "这之所以会起作用，是因为 Python 对一个类实例进行 pickle 操作，它记录了其 self 实例属性，以及实例所属类的名字和类的位置。当随后从 shelve 中获取 bob 并对其 unpickle 的时候，Python 将自动重新导入该类并将 bob 连接到它。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 更新 shelve 中的对象\n",
    "\n",
    "最后，我们编写一段程序，在每次运行的时候更新一个实例（记录），以证实此时我们的对象真的是持久的。下面的代码会打印出数据库信息，并且每次将所存储的对象 Sue 增加一次工资。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bob Smith \t=> [Person: job=None, name=Bob Smith, pay=0]\n",
      "Sue Jones \t=> [Person: job=dev, name=Sue Jones, pay=100000]\n",
      "Tom Jones \t=> [Manager: job=mgr, name=Tom Jones, pay=50000]\n"
     ]
    }
   ],
   "source": [
    "# File updatedb.py: update Person object on database\n",
    "\n",
    "import shelve\n",
    "# Reopen shelve with same filename\n",
    "db = shelve.open('persondb')\n",
    "\n",
    "# Iterate to display database objects\n",
    "for key in sorted(db):\n",
    "    print(key, '\\t=>', db[key]) # Prints with custom format\n",
    "\n",
    "sue = db['Sue Jones'] # Index by key to fetch\n",
    "sue.giveRaise(.10) # Update in memory using class's method\n",
    "db['Sue Jones'] = sue # Assign to key to update in shelve\n",
    "db.close() # Close after making changes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这段代码会显示出所有的记录并且每次运行时增加了 Sue 的工资。我们多次运行这段代码就可以看到对象的改变。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 练习\n",
    "\n",
    "1.Python 类中的 **self** 有什么意义？\n",
    "\n",
    "2.实现学生选课系统\n",
    "\n",
    "学生类\n",
    "\n",
    "- *属性*：姓名、学号、电话、所选课程列表\n",
    "- *方法*：**查看**：显示该学生所有课程信息；**添加课程**：将选好的课程添加到课程列表中\n",
    "        \n",
    "课程类\n",
    "\n",
    "- *属性*：课程编号、课程名称、教师名\n",
    "- *方法*：**查看**：显示该课程的全部信息；**设置教师**：给当前课程安排一个教师\n",
    "\n",
    "\n",
    "教师类：\n",
    "\n",
    "- *属性*：教师编号，教师名、电话、所教课程列表\n",
    "- *方法*：**查看**：查看该教师的所有课程\n",
    "\n",
    "完成以上三个类，并创建20名学生，6个课程，3名教师。给课程随机安排任课教师并给20名学生随机分配3个课程，最终显示这20名学生选课情况。"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.7"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": false,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "249px"
   },
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}