theory/python/eyes/7.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 第七章 类——面向对象的编程"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 引子"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Why：面向对象更符合人类对客观世界的抽象和理解**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* **一切皆对象**  \n",
    "一只小狗，一把椅子，一张信用卡，一条巧克力。。。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* **一切对象，都有自己内在的属性**  \n",
    "狗狗的品种、椅子的质地、信用卡的额度、巧克力的口味。。。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* **一切行为，皆是对象的行为**  \n",
    "狗狗蹲下、椅子移动位置、刷信用卡、巧克力融化了。。。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**How：类是对象的载体**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "不同年龄、肤色、品质的猫，每一只都是一个对象  \n",
    "  \n",
    "他们有一个共同的特征：都是猫  \n",
    "  \n",
    "我们可以把一类对象的公共特征抽象出来，创建通用的类"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 创建类\n",
    "class Cat():\n",
    "    \"\"\"模拟猫\"\"\"\n",
    "    \n",
    "    def __init__(self, name):\n",
    "        \"\"\"初始化属性\"\"\"\n",
    "        self.name = name\n",
    "    \n",
    "    def jump(self):\n",
    "        \"\"\"模拟猫跳跃\"\"\"\n",
    "        print(self.name + \" is jumping\") "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 用类创建实例\n",
    "my_cat = Cat(\"Loser\")\n",
    "your_cat = Cat(\"Lucky\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loser\n",
      "Lucky\n"
     ]
    }
   ],
   "source": [
    "# 调用属性\n",
    "print(my_cat.name)\n",
    "print(your_cat.name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loser is jumping\n",
      "Lucky is jumping\n"
     ]
    }
   ],
   "source": [
    "# 调用方法\n",
    "my_cat.jump()\n",
    "your_cat.jump()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 7.1 类的定义"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**三要素：类名、属性、方法**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7.1.1 类的命名"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 要有实际意义"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 驼峰命名法——组成的单词首字母大写  \n",
    "Dog、   CreditCard、   ElectricCar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "# class 类名：\n",
    "\"\"\"类前空两行\"\"\"\n",
    "\n",
    "\n",
    "class Car():\n",
    "    \"\"\"对该类的简单介绍\"\"\"\n",
    "    pass\n",
    "\n",
    "\"\"\"类后空两行\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7.1.2 类的属性"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "# def __init__(self,要传递的参数)  初始化类的属性"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Car():\n",
    "    \"\"\"模拟汽车\"\"\"\n",
    "    \n",
    "    def __init__(self, brand, model, year):\n",
    "        \"\"\"初始化汽车属性\"\"\"               # 相当于类内部的变量\n",
    "        self.brand = brand                 # 汽车的品牌\n",
    "        self.model = model                 # 汽车的型号\n",
    "        self.year = year                   # 汽车出厂年份\n",
    "        self.mileage = 0                   # 新车总里程初始化为0        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7.1.3 类的方法"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 相对于类内部定义的函数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Car():\n",
    "    \"\"\"模拟汽车\"\"\"\n",
    "    \n",
    "    def __init__(self, brand, model, year):\n",
    "        \"\"\"初始化汽车属性\"\"\"               # 相当于类内部的变量\n",
    "        self.brand = brand                 # 汽车的品牌\n",
    "        self.model = model                 # 汽车的型号\n",
    "        self.year = year                   # 汽车出厂年份\n",
    "        self.mileage = 0                   # 新车总里程初始化为0  \n",
    "        \n",
    "    def get_main_information(self):        # self不能省\n",
    "        \"\"\"获取汽车主要信息\"\"\"\n",
    "        print(\"品牌：{}   型号：{}   出厂年份：{}\".format(self.brand, self.model, self.year))\n",
    "    \n",
    "    def get_mileage(self):\n",
    "        \"\"\"获取总里程\"\"\"\n",
    "        return \"行车总里程：{}公里\".format(self.mileage)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 7.2 创建实例"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7.2.1 实例的创建"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "将实例赋值给对象，实例化过程中，传入相应的参数  \n",
    "v = 类名（必要的初始化参数）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_new_car = Car(\"Audi\", \"A6\", 2018)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7.2.2 访问属性"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "实例名.属性名"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Audi\n",
      "A6\n",
      "2018\n"
     ]
    }
   ],
   "source": [
    "print(my_new_car.brand)\n",
    "print(my_new_car.model)\n",
    "print(my_new_car.year)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7.2.3 调用方法"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Car():\n",
    "    \"\"\"模拟汽车\"\"\"\n",
    "    \n",
    "    def __init__(self, brand, model, year):\n",
    "        \"\"\"初始化汽车属性\"\"\"               # 相当于类内部的变量\n",
    "        self.brand = brand                 # 汽车的品牌\n",
    "        self.model = model                 # 汽车的型号\n",
    "        self.year = year                   # 汽车出厂年份\n",
    "        self.mileage = 0                   # 新车总里程初始化为0  \n",
    "        \n",
    "    def get_main_information(self):        # self不能省\n",
    "        \"\"\"获取汽车主要信息\"\"\"\n",
    "        print(\"品牌：{}   型号：{}   出厂年份：{}\".format(self.brand, self.model, self.year))\n",
    "    \n",
    "    def get_mileage(self):\n",
    "        \"\"\"获取总里程数\"\"\"\n",
    "        return \"行车总里程：{}公里\".format(self.mileage)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "实例名.方法名(必要的参数)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "品牌：Audi   型号：A6   出厂年份：2018\n"
     ]
    }
   ],
   "source": [
    "my_new_car = Car(\"Audi\", \"A6\", 2018)\n",
    "my_new_car.get_main_information()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "行车总里程：0公里\n"
     ]
    }
   ],
   "source": [
    "mileage = my_new_car.get_mileage()\n",
    "print(mileage)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7.2.4 修改属性"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**1、直接修改**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_old_car = Car(\"BYD\", \"宋\", 2016)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "先访问，后修改"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "12000\n"
     ]
    }
   ],
   "source": [
    "print(my_old_car.mileage)\n",
    "my_old_car.mileage = 12000\n",
    "print(my_old_car.mileage)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "行车总里程：12000公里\n"
     ]
    }
   ],
   "source": [
    "print(my_old_car.get_mileage())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**2、通过方法修改属性**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Car():\n",
    "    \"\"\"模拟汽车\"\"\"\n",
    "    \n",
    "    def __init__(self, brand, model, year):\n",
    "        \"\"\"初始化汽车属性\"\"\"               # 相当于类内部的变量\n",
    "        self.brand = brand                 # 汽车的品牌\n",
    "        self.model = model                 # 汽车的型号\n",
    "        self.year = year                   # 汽车出厂年份\n",
    "        self.mileage = 0                   # 新车总里程初始化为0  \n",
    "        \n",
    "    def get_main_information(self):        # self不能省\n",
    "        \"\"\"获取汽车主要信息\"\"\"\n",
    "        print(\"品牌：{}   型号：{}   出厂年份：{}\".format(self.brand, self.model, self.year))\n",
    "    \n",
    "    def get_mileage(self):\n",
    "        \"\"\"获取总里程数\"\"\"\n",
    "        return \"行车总里程：{}公里\".format(self.mileage)\n",
    "    \n",
    "    def set_mileage(self, distance):\n",
    "        \"\"\"设置总里程数\"\"\"\n",
    "        self.mileage = distance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "行车总里程：0公里\n",
      "行车总里程：8000公里\n"
     ]
    }
   ],
   "source": [
    "my_old_car = Car(\"BYD\", \"宋\", 2016)\n",
    "print(my_old_car.get_mileage())\n",
    "my_old_car.set_mileage(8000)\n",
    "print(my_old_car.get_mileage())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**3、继续拓展**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 禁止设置负里程  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "class Car():\n",
    "    \"\"\"模拟汽车\"\"\"\n",
    "    \n",
    "    def __init__(self, brand, model, year):\n",
    "        \"\"\"初始化汽车属性\"\"\"               # 相当于类内部的变量\n",
    "        self.brand = brand                 # 汽车的品牌\n",
    "        self.model = model                 # 汽车的型号\n",
    "        self.year = year                   # 汽车出厂年份\n",
    "        self.mileage = 0                   # 新车总里程初始化为0  \n",
    "        \n",
    "    def get_main_information(self):        # self不能省\n",
    "        \"\"\"获取汽车主要信息\"\"\"\n",
    "        print(\"品牌：{}   型号：{}   出厂年份：{}\".format(self.brand, self.model, self.year))\n",
    "    \n",
    "    def get_mileage(self):\n",
    "        \"\"\"获取总里程数\"\"\"\n",
    "        print(\"行车总里程：{}公里\".format(self.mileage)) \n",
    "    \n",
    "    def set_mileage(self, distance):\n",
    "        \"\"\"设置总里程数\"\"\"\n",
    "        if distance >= 0:\n",
    "            self.mileage = distance\n",
    "        else:\n",
    "            print(\"里程数不能为负！\")\n",
    "    \n",
    "    def increment_mileage(self, distance):\n",
    "        \"\"\"总里程数累计\"\"\"\n",
    "        if distance >= 0:\n",
    "            self.mileage += distance\n",
    "        else:\n",
    "            print(\"新增里程数不能为负！\") \n",
    "            "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "行车总里程：0公里\n",
      "里程数不能为负！\n",
      "行车总里程：0公里\n"
     ]
    }
   ],
   "source": [
    "my_old_car = Car(\"BYD\", \"宋\", 2016)\n",
    "my_old_car.get_mileage()\n",
    "my_old_car.set_mileage(-8000)\n",
    "my_old_car.get_mileage()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 将每次的里程数累加"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "行车总里程：0公里\n",
      "行车总里程：8000公里\n",
      "行车总里程：8500公里\n"
     ]
    }
   ],
   "source": [
    "my_old_car.get_mileage()\n",
    "my_old_car.set_mileage(8000)\n",
    "my_old_car.get_mileage()\n",
    "my_old_car.increment_mileage(500)\n",
    "my_old_car.get_mileage()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 小结"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_new_car = Car(\"Audi\", \"A6\", 2018)\n",
    "my_cars = [my_new_car, my_old_car]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 包含的信息量可以是极大的，可以创建无穷多的实例\n",
    "* 高度的拟人（物）化，符合人类对客观世界的抽象和理解"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 7.3 类的继承"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 引子"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**看一下人在生物界的分支链**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "生物——动物界——脊索动物门——哺乳动物纲——灵长目——人科——人属——智人种"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**公共特征逐渐增加的过程**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**【问题】**  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "假设二元系统：  人属 = {A人种， B人种， C人种。。。。}   \n",
    "为每一个人种构造一个类"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**方案一：**\n",
    "各自独立，分别构造各自人种的类"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**方案二：**  \n",
    "1、将各人种**公共特征提取出来**，建立人属的类；  \n",
    "2、各人种**继承上一级（人属）的公共特征，然后添加自身特殊特征**，构建各自人种的类。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "通常，我们选择方案二，因为他避免了过多的重复劳动"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**所谓继承，就是低层抽象继承高层抽象的过程**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7.3.1 简单的继承"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**父类**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Car():\n",
    "    \"\"\"模拟汽车\"\"\"\n",
    "    \n",
    "    def __init__(self, brand, model, year):\n",
    "        \"\"\"初始化汽车属性\"\"\"               # 相当于类内部的变量\n",
    "        self.brand = brand                 # 汽车的品牌\n",
    "        self.model = model                 # 汽车的型号\n",
    "        self.year = year                   # 汽车出厂年份\n",
    "        self.mileage = 0                   # 新车总里程初始化为0\n",
    "        \n",
    "        \n",
    "    def get_main_information(self):        # self不能省\n",
    "        \"\"\"获取汽车主要信息\"\"\"\n",
    "        print(\"品牌：{}   型号：{}   出厂年份：{}\".format(self.brand, self.model, self.year))\n",
    "    \n",
    "    def get_mileage(self):\n",
    "        \"\"\"获取总里程数\"\"\"\n",
    "        print(\"行车总里程：{}公里\".format(self.mileage)) \n",
    "    \n",
    "    def set_mileage(self, distance):\n",
    "        \"\"\"设置总里程数\"\"\"\n",
    "        if distance >= 0:\n",
    "            self.mileage = distance\n",
    "        else:\n",
    "            print(\"里程数不能为负！\")\n",
    "    \n",
    "    def increment_mileage(self, distance):\n",
    "        \"\"\"总里程数累计\"\"\"\n",
    "        if distance >= 0:\n",
    "            self.mileage += distance\n",
    "        else:\n",
    "            print(\"新增里程数不能为负！\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**子类**  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "class 子类名（父类名）："
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 新建一个电动汽车的类"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ElectricCar(Car):\n",
    "    \"\"\"模拟电动汽车\"\"\"\n",
    "    \n",
    "    def __init__(self, brand, model, year):\n",
    "        \"\"\"初始化电动汽车属性\"\"\"\n",
    "        super().__init__(brand, model, year)  # 声明继承父类的属性"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 自动继承父类的所有方法"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "品牌：NextWeek   型号：FF91   出厂年份：2046\n"
     ]
    }
   ],
   "source": [
    "my_electric_car = ElectricCar(\"NextWeek\", \"FF91\", 2046)\n",
    "my_electric_car.get_main_information()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7.3.2 给子类添加属性和方法"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ElectricCar(Car):\n",
    "    \"\"\"模拟电动汽车\"\"\"\n",
    "    \n",
    "    def __init__(self, brand, model, year, bettery_size):\n",
    "        \"\"\"初始化电动汽车属性\"\"\"\n",
    "        super().__init__(brand, model, year)    # 声明继承父类的属性\n",
    "        self.bettery_size = bettery_size        # 电池容量\n",
    "        self.electric_quantity = bettery_size   # 电池剩余电量\n",
    "        self.electric2distance_ratio = 5        # 电量距离换算系数 5公里/kW.h\n",
    "        self.remainder_range = self.electric_quantity*self.electric2distance_ratio # 剩余可行驶里程\n",
    "    \n",
    "    def get_electric_quantit(self):\n",
    "        \"\"\"查看当前电池电量\"\"\"\n",
    "        print(\"当前电池剩余电量：{} kW.h\".format(self.electric_quantity))\n",
    "        \n",
    "    def set_electric_quantity(self, electric_quantity):\n",
    "        \"\"\"设置电池剩余电量，重新计算电量可支撑行驶里程\"\"\"\n",
    "        if electric_quantity >= 0 and electric_quantity <= self.bettery_size:\n",
    "            self.electric_quantity = electric_quantity\n",
    "            self.remainder_range = self.electric_quantity*self.electric2distance_ratio\n",
    "        else:\n",
    "            print(\"电量未设置在合理范围！\")\n",
    "    \n",
    "    def get_remainder_range(self):\n",
    "        \"\"\"查看剩余可行驶里程\"\"\"\n",
    "        print(\"当前电量还可以继续驾驶 {} 公里\".format(self.remainder_range))              "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "当前电池剩余电量：70 kW.h\n",
      "当前电量还可以继续驾驶 350 公里\n"
     ]
    }
   ],
   "source": [
    "my_electric_car = ElectricCar(\"NextWeek\", \"FF91\", 2046, 70)\n",
    "my_electric_car.get_electric_quantit()            # 获取当前电池电量\n",
    "my_electric_car.get_remainder_range()             # 获取当前剩余可行驶里程"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "当前电池剩余电量：50 kW.h\n",
      "当前电量还可以继续驾驶 250 公里\n"
     ]
    }
   ],
   "source": [
    "my_electric_car.set_electric_quantity(50)         # 重设电池电量\n",
    "my_electric_car.get_electric_quantit()            # 获取当前电池电量\n",
    "my_electric_car.get_remainder_range()             # 获取当前剩余可行驶里程"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7.3.3 重写父类的方法——多态"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ElectricCar(Car):\n",
    "    \"\"\"模拟电动汽车\"\"\"\n",
    "    \n",
    "    def __init__(self, brand, model, year, bettery_size):\n",
    "        \"\"\"初始化电动汽车属性\"\"\"\n",
    "        super().__init__(brand, model, year)    # 声明继承父类的属性\n",
    "        self.bettery_size = bettery_size        # 电池容量\n",
    "        self.electric_quantity = bettery_size   # 电池剩余电量\n",
    "        self.electric2distance_ratio = 5        # 电量距离换算系数 5公里/kW.h\n",
    "        self.remainder_range = self.electric_quantity*self.electric2distance_ratio # 剩余可行驶里程\n",
    "    \n",
    "    def get_main_information(self):        # 重写父类方法\n",
    "        \"\"\"获取汽车主要信息\"\"\"\n",
    "        print(\"品牌：{}   型号：{}   出厂年份：{}   续航里程：{} 公里\"\n",
    "              .format(self.brand, self.model, self.year, self.bettery_size*self.electric2distance_ratio))\n",
    "    \n",
    "    def get_electric_quantit(self):\n",
    "        \"\"\"查看当前电池电量，重新计算电量可支撑行驶里程\"\"\"\n",
    "        print(\"当前电池剩余电量：{} kW.h\".format(self.electric_quantity))\n",
    "        \n",
    "    def set_electric_quantity(self, electric_quantity):\n",
    "        \"\"\"设置电池剩余电量\"\"\"\n",
    "        if electric_quantity >= 0 and electric_quantity <= self.bettery_size:\n",
    "            self.electric_quantity = electric_quantity\n",
    "            self.remainder_range = self.electric_quantity*self.electric2distance_ratio\n",
    "        else:\n",
    "            print(\"电量未设置在合理范围！\")\n",
    "    \n",
    "    def get_remainder_range(self):\n",
    "        \"\"\"查看剩余可行驶里程\"\"\"\n",
    "        print(\"当前电量还可以继续驾驶 {} 公里\".format(self.remainder_range))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "品牌：NextWeek   型号：FF91   出厂年份：2046   续航里程：350 公里\n"
     ]
    }
   ],
   "source": [
    "my_electric_car = ElectricCar(\"NextWeek\", \"FF91\", 2046, 70)\n",
    "my_electric_car.get_main_information()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7.3.4 用在类中的实例"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "把电池抽象成一个对象  \n",
    "逻辑更加清晰"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Bettery():\n",
    "    \"\"\"模拟电动汽车的电池\"\"\"\n",
    "    \n",
    "    def __init__(self, bettery_size = 70):\n",
    "        self.bettery_size = bettery_size        # 电池容量\n",
    "        self.electric_quantity = bettery_size   # 电池剩余电量\n",
    "        self.electric2distance_ratio = 5        # 电量距离换算系数 5公里/kW.h\n",
    "        self.remainder_range = self.electric_quantity*self.electric2distance_ratio # 剩余可行驶里程\n",
    "\n",
    "    def get_electric_quantit(self):\n",
    "        \"\"\"查看当前电池电量\"\"\"\n",
    "        print(\"当前电池剩余电量：{} kW.h\".format(self.electric_quantity))\n",
    "        \n",
    "    def set_electric_quantity(self, electric_quantity):\n",
    "        \"\"\"设置电池剩余电量，计重新算电量可支撑行驶里程\"\"\"\n",
    "        if electric_quantity >= 0 and electric_quantity <= self.bettery_size:\n",
    "            self.electric_quantity = electric_quantity\n",
    "            self.remainder_range = self.electric_quantity*self.electric2distance_ratio\n",
    "        else:\n",
    "            print(\"电量未设置在合理范围！\")\n",
    "    \n",
    "    def get_remainder_range(self):\n",
    "        \"\"\"查看剩余可行驶里程\"\"\"\n",
    "        print(\"当前电量还可以继续驾驶 {} 公里\".format(self.remainder_range))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ElectricCar(Car):\n",
    "    \"\"\"模拟电动汽车\"\"\"\n",
    "    \n",
    "    def __init__(self, brand, model, year, bettery_size):\n",
    "        \"\"\"初始化电动汽车属性\"\"\"\n",
    "        super().__init__(brand, model, year)    # 声明继承父类的属性\n",
    "        self.bettery = Bettery(bettery_size)    # 电池\n",
    "    \n",
    "    def get_main_information(self):        # 重写父类方法\n",
    "        \"\"\"获取汽车主要信息\"\"\"\n",
    "        print(\"品牌：{}   型号：{}   出厂年份：{}   续航里程：{} 公里\"\n",
    "              .format(self.brand, self.model, self.year, \n",
    "              self.bettery.bettery_size*self.bettery.electric2distance_ratio))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "品牌：NextWeek   型号：FF91   出厂年份：2046   续航里程：350 公里\n"
     ]
    }
   ],
   "source": [
    "my_electric_car = ElectricCar(\"NextWeek\", \"FF91\", 2046, 70)\n",
    "my_electric_car.get_main_information()                  # 获取车辆主要信息"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "当前电池剩余电量：70 kW.h\n"
     ]
    }
   ],
   "source": [
    "my_electric_car.bettery.get_electric_quantit()          # 获取当前电池电量"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_electric_car.bettery.set_electric_quantity(50)       # 重设电池电量"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "当前电池剩余电量：50 kW.h\n"
     ]
    }
   ],
   "source": [
    "my_electric_car.bettery.get_electric_quantit()          # 获取当前电池电量    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "当前电量还可以继续驾驶 250 公里\n"
     ]
    }
   ],
   "source": [
    "my_electric_car.bettery.get_remainder_range()           # 获取当前剩余可行驶里程"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}