Fullstack_day24&25_类对象.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "collapsed_sections": [],
      "authorship_tag": "ABX9TyP5uduiYFZZ6Y7TZjPoyZFq",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/leiyi-ihb/ColabPractics/blob/main/Fullstack_day24%2625_%E7%B1%BB%E5%AF%B9%E8%B1%A1.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "JCmTQnJKC4kD",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "137554a8-818a-46a4-87bc-d964732e5a28"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "你调用Dog类了哦\n",
            "Duangis sitting down now hahha55\n",
            "I like the dog\n",
            "你调用Dog类了哦\n",
            "bilirolled over\n",
            "None\n"
          ]
        }
      ],
      "source": [
        "class Dog():\n",
        "  #给小狗的简单指令\n",
        "  def __init__(self, name, age): #调用类的时候就会自动执行__init__方法，该方法有个特殊别名叫\"构造方法\"    \n",
        "    self.name=name\n",
        "    self.age=age\n",
        "    print(\"你调用Dog类了哦\") #后面函数的共有字段，就可以放到该方法中了   \n",
        "  def sit(self, baba):\n",
        "    #命令小狗蹲下\n",
        "    print(self.name + \"is sitting down now %s\" %(baba) + str(self.age))\n",
        "    return \"I like the dog\"\n",
        "  def roll_over(self):\n",
        "    #命令小狗打滚\n",
        "    print(self.name + \"rolled over\")\n",
        "\n",
        "if __name__== '__main__':\n",
        "  my_dog=Dog(\"Duang\", 55) #调用类就要传参数name, age\n",
        "  rent=my_dog.sit(\"hahha\")\n",
        "  print(rent)\n",
        "  my_dog2=Dog(\"bili\", 12)\n",
        "  rat=my_dog2.roll_over()\n",
        "  print(rat) \n",
        "    "
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Python中的面向对象编程  \n",
        "通过前面的学习，我们已经掌握了函数，`在Python中又叫函数式编程`。接下来我们学习Python的第二种编程方式 == 面向对象编程【**类**】\n",
        "\n",
        "创建类的格式:  \n",
        "class 类名:  \n",
        "-----def __init__(self...):  #构造方法\n",
        "--------pass  \n",
        "-----def 方法名():  #方法\n",
        "--------pass  \n",
        "\n",
        "`类的调用`：1、创建对象；2、对象调用方法  \n",
        "if __name__=='__main__':  \n",
        "--obj = 类名()   \n",
        "--obj.方法名() \n",
        "\n"
      ],
      "metadata": {
        "id": "KtXWesrVNZYy"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# 定义一个简单的类\n",
        "'''\n",
        "输出4个人的如下内容：\n",
        "姓名 年龄 性别 要做的事\n",
        "'''\n",
        "\n",
        "class Bar:\n",
        "  def __init__(self):\n",
        "    pass\n",
        "  def add(self, content):\n",
        "    print(self.name, self.age, self.gender, content)\n",
        "  def delete(self, content):\n",
        "    print(self.name, self.age, self.gender, content)\n",
        "  def update(self, content):\n",
        "    print(self.name, self.age, self.gender, content)\n",
        "  def get(self, content):\n",
        "    print(self.name, self.age, self.gender, content)\n",
        "if __name__=='__main__':\n",
        "  obj=Bar()\n",
        "  obj.name=\"xiao\"\n",
        "  obj.age=2\n",
        "  obj.gender=\"male\"\n",
        "  obj.add(\"上山去打野猪\")\n",
        "\n",
        "  obj2=Bar()\n",
        "  obj2.name=\"fish\"\n",
        "  obj2.age=22\n",
        "  obj2.gender=\"female\"\n",
        "  obj2.add(\"下河抓鱼\")\n",
        "\n",
        "  obj3=Bar()\n",
        "  obj3.name=\"midl\"\n",
        "  obj3.age=98\n",
        "  obj3.gender=\"male\"\n",
        "  obj3.add(\"家里煮饭\")\n",
        "\n",
        "  obj4=Bar()\n",
        "  obj4.name=\"you\"\n",
        "  obj4.age=198\n",
        "  obj4.gender=\"male\"\n",
        "  obj4.add(\"睡觉\") #可以发现，每次都需要重新定义一下参数self.name, self.age和self.gender【如果调用无数次，那不就废了】。这下就可以体现处构造函数的优势了【如下】\n",
        "    "
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-YC2IT5LrlEB",
        "outputId": "5bac704c-af0f-4477-9542-2a6f729372f0"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "xiao 2 male 上山去打野猪\n",
            "fish 22 female 下河抓鱼\n",
            "midl 98 male 家里煮饭\n",
            "you 198 male 睡觉\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 从上面的例子中可以发现，`类`相比于`函数`而言，更适合在函数间具有一些相同代码时使用\n",
        "### 接下来看看类的一些重点\n",
        "#### 构造方法\n"
      ],
      "metadata": {
        "id": "cT0EEdkG_wHf"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Bar:\n",
        "  def __init__(self, n, a, g): #针对上面例子我们把构造方法用起来\n",
        "    self.name=n\n",
        "    self.age=a\n",
        "    self.gender=g\n",
        "  def add(self, content):\n",
        "    print(self.name, self.age, self.gender, content)\n",
        "  def delete(self, content):\n",
        "    print(self.name, self.age, self.gender, content)\n",
        "  def update(self, content):\n",
        "    print(self.name, self.age, self.gender, content)\n",
        "  def get(self, content):\n",
        "    print(self.name, self.age, self.gender, content)\n",
        "\n",
        "if __name__=='__main__':\n",
        "  obj=Bar(\"xiao\",2,\"male\")\n",
        "  obj.add(\"上山去打野猪\")\n",
        "\n",
        "  obj2=Bar(\"fish\",22,\"female\")\n",
        "  obj2.add(\"下河抓鱼\")\n",
        "\n",
        "  obj3=Bar(\"midl\",98,\"male\")\n",
        "  obj3.add(\"家里煮饭\")\n",
        "\n",
        "  obj4=Bar(\"you\",198,\"male\")\n",
        "  obj4.add(\"睡觉\")  \n",
        "\n",
        "# Q: 可以发现性别大多数都是\"male\"，因此可以使用默认函数【如下修改】"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SlzcLOXzuC_a",
        "outputId": "062ba17d-5854-453f-d9a6-73d31468e8dc"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "xiao 2 male 上山去打野猪\n",
            "fish 22 female 下河抓鱼\n",
            "midl 98 male 家里煮饭\n",
            "you 198 male 睡觉\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "class Bar:\n",
        "  def __init__(self, n, a, g=\"male\"):  #g写成了默认参数\n",
        "    '''\n",
        "    针对上面例子我们把构造方法用起来\n",
        "    构造方法的特性\n",
        "    构造方法调用时自动执行\n",
        "    '''\n",
        "    print(\"调用Bar了哦\")\n",
        "    self.name=n\n",
        "    self.age=a\n",
        "    self.gender=g\n",
        "    self.blood=\"O\" #可以发现，直接写死，都可以不用默认参数。参数，只是让我们更加灵活。\n",
        "  def add(self, content):\n",
        "    print(self.name, self.age, self.gender, content, self.blood)\n",
        "  def delete(self, content):\n",
        "    print(self.name, self.age, self.gender, content, self.blood)\n",
        "  def update(self, content):\n",
        "    print(self.name, self.age, self.gender, content, self.blood)\n",
        "  def get(self, content):\n",
        "    print(self.name, self.age, self.gender, content, self.blood)\n",
        "\n",
        "if __name__=='__main__':\n",
        "  obj=Bar(\"xiao\",2)\n",
        "  obj.add(\"上山去打野猪\")\n",
        "\n",
        "  obj2=Bar(\"fish\",22,\"female\")\n",
        "  obj2.add(\"下河抓鱼\")\n",
        "\n",
        "  obj3=Bar(\"midl\",98)\n",
        "  obj3.add(\"家里煮饭\")\n",
        "\n",
        "  obj4=Bar(\"you\",198)\n",
        "  obj4.add(\"睡觉\")  "
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8mx5oV-iwkHB",
        "outputId": "c5075f56-9456-47b9-9ada-c570dc9b1588"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "调用Bar了哦\n",
            "xiao 2 male 上山去打野猪 O\n",
            "调用Bar了哦\n",
            "fish 22 female 下河抓鱼 O\n",
            "调用Bar了哦\n",
            "midl 98 male 家里煮饭 O\n",
            "调用Bar了哦\n",
            "you 198 male 睡觉 O\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 但是上面需要注意的是，就算参数写死了，在外面也是可以修改的哦\n",
        "class Bar:\n",
        "  def __init__(self, n, a, g=\"male\"):  #g写成了默认参数\n",
        "    '''\n",
        "    针对上面例子我们把构造方法用起来\n",
        "    构造方法的特性\n",
        "    构造方法调用时自动执行\n",
        "    '''\n",
        "    print(\"调用Bar了哦\")\n",
        "    self.name=n\n",
        "    self.age=a\n",
        "    self.gender=g\n",
        "    self.blood=\"O\" # 在外面调用时，对此进行修改\n",
        "  def add(self, content):\n",
        "    print(self.name, self.age, self.gender, content, self.blood)\n",
        "  def delete(self, content):\n",
        "    print(self.name, self.age, self.gender, content, self.blood)\n",
        "  def update(self, content):\n",
        "    print(self.name, self.age, self.gender, content, self.blood)\n",
        "  def get(self, content):\n",
        "    print(self.name, self.age, self.gender, content, self.blood)\n",
        "\n",
        "if __name__=='__main__':\n",
        "  obj=Bar(\"xiao\",2)\n",
        "  obj.add(\"上山去打野猪\")\n",
        "\n",
        "  obj2=Bar(\"fish\",22,\"female\")\n",
        "  obj2.blood = \"AB\" # 修改了里面的参数，就相当于给参数重新赋值\n",
        "  obj2.add(\"下河抓鱼\")\n",
        "\n",
        "  obj3=Bar(\"midl\",98)\n",
        "  obj3.add(\"家里煮饭\")\n",
        "\n",
        "  obj4=Bar(\"you\",198)\n",
        "  obj4.add(\"睡觉\")"
      ],
      "metadata": {
        "id": "LJML4-8qeG3T"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# 上面的这种参数也可以定义在类里边的其他地方，这样在别的方法中也是能调用的\n",
        "\n",
        "class Father:\n",
        "  def __init__(self, n, a, work) -> None:\n",
        "    print(\"调用father class了\")\n",
        "    '''\n",
        "    1、注意方法的返回值\n",
        "    2、类中，方法间的变量调用\n",
        "    '''\n",
        "    self.name = n\n",
        "    self.age = a\n",
        "    self.work = work  #\n",
        "  def smoker(self, enjoy):\n",
        "    print(self.name, \"'s father is %s\" %(self.age), \"and he enjoy %s\" %(enjoy), \"but he is a smoker\", \"Like %s\" %(self.work))\n",
        "    x = \"野猪\" #这种变量定义方式能在别的方法中不能调用 【如果想在别的函数中调用该怎么办呢？？这就涉及到函数的作用域了LEGB（其实一般不会有这种要求，因为函数内是不能定义全局变量的https://segmentfault.com/q/1010000013799154）】\n",
        "    self.m = \"hello\" #这种变量定义方式能在别的方法中调用\n",
        "    return \"Father is a smoker\"\n",
        "  def drink(self, gender):\n",
        "    print(self.name, \"'s mother is %s\" %(self.age), \"and she is a %s\" %(gender), \"but she is a drinker\", \"Like %s\" %(self.work))    \n",
        "    return \"Father is a drinker\"\n",
        "  def school(self, university):\n",
        "    inter = self.smoker(self)  #类中，方法间的变量怎样调用？？ https://blog.csdn.net/weixin_42550871/article/details/108700848\n",
        "    self.smoker(self)\n",
        "    print(self.name, \"'s brother is %s\" %(self.age), \"and he is graduate from %s\" %(university), \"but don't like %s\" %(inter), \"but don't like %s\" %(self.m), \"Like %s\" %(self.work))\n",
        "    return \"haha\"\n",
        "\n",
        "if __name__=='__main__':\n",
        "  obj=Father(\"alix\", \"45\", \"Compute Science\")\n",
        "  tmp1 = obj.drink(\"male\")\n",
        "  tmp2 = obj.school(\"wuhan\")\n",
        "  print (tmp1, tmp2, \"The program is over\")\n",
        "\n",
        "  ### 学了下面的静态字段，会过来看这里的变量\"x\"，其实他也不是静态字段，按静态字段的调用方式，也是会报错的：\n",
        "  # print(Father.x) #AttributeError: 'Father' object has no attribute 'x'\n",
        "  print(obj.x) #\n",
        "  "
      ],
      "metadata": {
        "id": "1fYZqEFRDaYS",
        "outputId": "583270ae-3caf-488b-b3cf-1b08181903b2",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 321
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "调用father class了\n",
            "alix 's mother is 45 and she is a male but she is a drinker Like Compute Science\n",
            "alix 's father is 45 and he enjoy <__main__.Father object at 0x7ffade1cfdd0> but he is a smoker Like Compute Science\n",
            "alix 's father is 45 and he enjoy <__main__.Father object at 0x7ffade1cfdd0> but he is a smoker Like Compute Science\n",
            "alix 's brother is 45 and he is graduate from wuhan but don't like Father is a smoker but don't like hello Like Compute Science\n",
            "Father is a drinker haha The program is over\n"
          ]
        },
        {
          "output_type": "error",
          "ename": "AttributeError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-10-a23b8d9148b8>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     33\u001b[0m   \u001b[0;31m### 学了下面的静态字段，会过来看这里的变量\"x\"，其实他也不是静态字段，按静态字段的调用方式，也是会报错的：\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     34\u001b[0m   \u001b[0;31m# print(Father.x) #AttributeError: 'Father' object has no attribute 'x'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 35\u001b[0;31m   \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m#\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     36\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mAttributeError\u001b[0m: 'Father' object has no attribute 'x'"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**小结：**通过上面，已经明白了类的创建，调用，构造方法，和参数。 接下来可以进一步学习类的三大特性了。"
      ],
      "metadata": {
        "id": "2ely32lfCdNO"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 类的三大特性\n",
        "### 类的三大特性之一（继承）"
      ],
      "metadata": {
        "id": "8GnOkiOA_YqW"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 继承\n",
        "两个概念：`父类`（基类），`子类`（派生类）  \n",
        "继承跟现实生活中是一样的。可以全继承，也可以选择性继承"
      ],
      "metadata": {
        "id": "BecUBgj7oJbf"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Grandfather:\n",
        "  def __init__(self) -> None:\n",
        "    pass\n",
        "  def trivel(self):\n",
        "    pass\n",
        "  def book(self):\n",
        "    pass\n",
        "\n",
        "class Father: # 父类-基类\n",
        "  def __init__(self) -> None:\n",
        "    pass\n",
        "  def basketball(self):\n",
        "    pass\n",
        "  def football(self):\n",
        "    pass\n",
        "  def smoke(self):\n",
        "    pass\n",
        "  def drink(self):\n",
        "    pass\n",
        "\n",
        "class Son(Father): #实现了全继承(子类-派生类)。\n",
        "  def __init__(self) -> None:\n",
        "    super().__init__()\n",
        "  def pingpeng(self):\n",
        "    pass\n",
        "\n",
        "if __name__=='__main__':\n",
        "  obj = Son()\n",
        "  obj.pingpeng()\n",
        "  obj.basketball()\n",
        "  # obj.trivel() #会报错，无法继承到Grandfather"
      ],
      "metadata": {
        "id": "aTqTuqTZn9Sx"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "'''如何能继承Grandfather呢？\n",
        "   只需让Father继承Grandfather就行，这样Son就可以继承Grandfather了'''\n",
        "class Grandfather:\n",
        "  def __init__(self) -> None:\n",
        "    pass\n",
        "  def trivel(self):\n",
        "    pass\n",
        "  def book(self):\n",
        "    pass\n",
        "\n",
        "class Father(Grandfather): # 父类-基类\n",
        "  def __init__(self) -> None:\n",
        "    pass\n",
        "  def basketball(self):\n",
        "    pass\n",
        "  def football(self):\n",
        "    pass\n",
        "  def smoke(self):\n",
        "    pass\n",
        "  def drink(self):\n",
        "    pass\n",
        "\n",
        "class Son(Father): #实现了全继承(子类-派生类)。\n",
        "  def __init__(self) -> None:\n",
        "    super().__init__()\n",
        "  def pingpeng(self):\n",
        "    pass\n",
        "\n",
        "if __name__=='__main__':\n",
        "  obj = Son()\n",
        "  obj.pingpeng()\n",
        "  obj.basketball()\n",
        "  obj.trivel() #能继承到Grandfather"
      ],
      "metadata": {
        "id": "0RURBejnr3iw"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 选择性继承\n",
        "选择性继承的实质，**就相当于改写已有的方法**，如下子类自己定义了自己的smoke方法"
      ],
      "metadata": {
        "id": "PczOUsFZsmPG"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Father: # 父类-基类\n",
        "  def __init__(self) -> None:\n",
        "    pass\n",
        "  def basketball(self):\n",
        "    pass\n",
        "  def football(self):\n",
        "    pass\n",
        "  def smoke(self):\n",
        "    print(\"I am a smoker\")\n",
        "  def drink(self):\n",
        "    pass\n",
        "\n",
        "class Son(Father): #实现了全继承(子类-派生类)。\n",
        "  def __init__(self) -> None:\n",
        "    super().__init__()\n",
        "  def pingpeng(self):\n",
        "    pass\n",
        "  def smoke(self):\n",
        "    print(\"Never smoker\")\n",
        "\n",
        "if __name__=='__main__':\n",
        "  obj = Son()\n",
        "  obj.pingpeng()\n",
        "  obj.smoke() #这样就不会调用父类的smock方法了（其实就是一个查找的先后顺序，找到了就停止继续查找了）\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GV6eGl3Wsqqe",
        "outputId": "70e06a41-cec7-4a7a-9b02-763a2b6456cb"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Never smoker\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# 问题：既想执行自己的，又想执行父类的，该怎么办？？\n",
        "1、使用supper  \n",
        "2、直接强制调用"
      ],
      "metadata": {
        "id": "sAHtTloyv-Dn"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "rhnCsJsSwBgp"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "class Father: # 父类-基类\n",
        "  def __init__(self) -> None:\n",
        "    pass\n",
        "  def basketball(self):\n",
        "    pass\n",
        "  def football(self):\n",
        "    pass\n",
        "  def smoke(self):\n",
        "    print(\"I am a smoker\")\n",
        "  def drink(self):\n",
        "    pass\n",
        "\n",
        "class Son(Father): #实现了全继承(子类-派生类)。\n",
        "  def __init__(self) -> None:\n",
        "    super().__init__() #这下明白这里的代码可以怎样写了吗?\n",
        "  def pingpeng(self):\n",
        "    pass\n",
        "  def smoke(self):\n",
        "    super(Son, self).smoke() #方式1、找到父类，并执行父类的smoke方法（当然执行父类的啥方法都是可以的）\n",
        "    print(\"Never smoker\")\n",
        "    Father.smoke(self) #方式2、主动调用\n",
        "\n",
        "if __name__=='__main__':\n",
        "  obj = Son()\n",
        "  obj.pingpeng()\n",
        "  obj.smoke()\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "01a114b8-697d-4936-c946-8875ae6a80a9",
        "id": "ZSe4H6sHwKQ_"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "I am a smoker\n",
            "Never smoker\n",
            "I am a smoker\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 一个类可能继承多个父类【多继承】  \n",
        "可以想象一个问题：当继承多个父类的时候，如果两个父类间有重叠的方法，它是怎么处理的呢？  \n",
        "规则：自己==》左边父类==》右边父类"
      ],
      "metadata": {
        "id": "CpVOcKFv62YL"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Father1和Father2中都有方法book\n",
        "class Father1:\n",
        "  def __init__(self) -> None:\n",
        "    pass\n",
        "  def trivel(self):\n",
        "    pass\n",
        "  def book(self):\n",
        "    print(\"chinese\") \n",
        "\n",
        "class Father2: \n",
        "  def __init__(self) -> None:\n",
        "    pass\n",
        "  def basketball(self):\n",
        "    pass\n",
        "  def football(self):\n",
        "    pass\n",
        "  def smoke(self):\n",
        "    pass\n",
        "  def drink(self):\n",
        "    pass\n",
        "  def book(self):\n",
        "    print(\"math\")\n",
        "\n",
        "class Son(Father1, Father2): #同时继承两个父类\n",
        "  def __init__(self) -> None:\n",
        "    super().__init__()\n",
        "  def pingpeng(self):\n",
        "    pass\n",
        "\n",
        "if __name__=='__main__':\n",
        "  obj = Son()\n",
        "  obj.book() #查找方法为：自己-->左边父类-->右边父类\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vARp0uAJ7ijc",
        "outputId": "f6f58f8d-678c-4e4d-c5e1-1f0f8e0b5b96"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "chinese\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 上面例子中，如果其中一个父类又继承了别人呢，查找的优先顺序又是咋样的呢？\n",
        "规则：自己找完==》左边找完==》右边找完\n",
        "\n",
        "# 但又出现一个问题：如果左右两个按不同路线继承，但最终汇聚继承到同一个类呢？？\n",
        "如：Son(Father1, Father2)  \n",
        "--------------Father1(Father1_0)  \n",
        "--------------Father1_0(Father1_1)  \n",
        "--------------Father1_1(FatherBase)\n",
        "\n",
        "--------------Father2(Father2_0)  \n",
        "--------------Father2_0(Father2_1)  \n",
        "--------------Father2_1(FatherBase) `FatherBase相当于根`\n",
        "\n",
        "规则:自己找完==》左边找完==》右边找完 `【最后找根】`\n"
      ],
      "metadata": {
        "id": "4xx8mMeG836I"
      }
    },
    {
      "cell_type": "markdown",
      "source": [],
      "metadata": {
        "id": "ThcDZNieEcyr"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 理解下面例子中process_request的调用途径"
      ],
      "metadata": {
        "id": "hRCrP3yoEdIP"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class BaseRequest:\n",
        "  pass\n",
        "\n",
        "class RequestMandler(BaseRequest):\n",
        "  def server_forever(self):\n",
        "    print(\"RequestMandler.server_forever\")\n",
        "    self.process_request() #请问这里的process_request会先执行哪一个？\n",
        "  def process_request(self):\n",
        "    print(\"RequestMandler.process_request\")\n",
        "  pass\n",
        "\n",
        "class Minx:\n",
        "  def process_request(self):    \n",
        "    print(\"Minx.process_request\")\n",
        "  \n",
        "class Son(Minx, RequestMandler):\n",
        "  pass\n",
        "\n",
        "if __name__=='__main__':\n",
        "  obj=Son()\n",
        "  obj.process_request()\n",
        "  obj.server_forever()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c25bb3c6-d847-4646-9328-48b057582841",
        "id": "w2LTb1bSEh3y"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Minx.process_request\n",
            "RequestMandler.server_forever\n",
            "Minx.process_request\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 上面例子中：加入__init__方法  \n",
        "一定要理清楚调用的规则哦"
      ],
      "metadata": {
        "id": "y_QuypgbEvyk"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class BaseRequest:\n",
        "  def __init__(self) -> None:\n",
        "    print(\"BaseRequest.init\")\n",
        "\n",
        "class RequestMandler(BaseRequest):\n",
        "  def __init__(self) -> None:\n",
        "    # super().__init__()\n",
        "    # BaseRequest.__init__(self) #加上就能同时执行BaseRequest中的__init__方法\n",
        "    print(\"RequestMandler.init\")\n",
        "  def server_forever(self):\n",
        "    print(\"RequestMandler.server_forever\")\n",
        "    self.process_request() #请问这里的process_request会先执行哪一个？\n",
        "  def process_request(self):\n",
        "    print(\"RequestMandler.process_request\")\n",
        "  pass\n",
        "\n",
        "class Minx:\n",
        "  def process_request(self):    \n",
        "    print(\"Minx.process_request\")\n",
        "  \n",
        "class Son(Minx, RequestMandler):\n",
        "  pass\n",
        "\n",
        "if __name__=='__main__':\n",
        "  obj=Son()\n",
        "  # obj.process_request()\n",
        "  # obj.server_forever()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ctcVxf-WE9Js",
        "outputId": "c10db117-9901-4731-a5af-a780318ac852"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "BaseRequest.init\n",
            "RequestMandler.init\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#在Pycharm中练习查找执行流程：确定1处需要几个参数；确定2处需要几个参数\n",
        "import socketserver\n",
        "obj = socketserver.ThreadingTCPServer() #1\n",
        "obj.process_request() #2"
      ],
      "metadata": {
        "id": "oJ2sDiQ8HF_T"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 以上就是继承的所有内容，接下来看面向对象的三大特性之三：多态\n",
        "python中忽略就行了\n"
      ],
      "metadata": {
        "id": "d0oIH3ibSxEm"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Dog():\n",
        "  #给小狗的简单指令\n",
        "  def __init__(self): #调用类的时候就会自动执行__init__方法，该方法有个特殊别名叫\"构造方法\"    \n",
        "    # self.name=name\n",
        "    # self.age=age\n",
        "    print(\"你调用Dog类了哦\") #后面函数的共有字段，就可以放到该方法中了   \n",
        "  def sit(self, baba):\n",
        "    #命令小狗蹲下\n",
        "    print(self.name + \"is sitting down now %s\" %(baba) + str(self.age))\n",
        "    return \"I like the dog\"\n",
        "  def roll_over(self):\n",
        "    #命令小狗打滚\n",
        "    print(self.name + \"rolled over\")\n",
        "\n",
        "if __name__== '__main__':\n",
        "  my_dog=Dog() #如果构造方法不传参数,可以发现每次都要该name和age，如果加入参数，直接将name和age作为参数传入了\n",
        "  my_dog.age=10\n",
        "  my_dog.name=\"shark\"\n",
        "  rent=my_dog.sit(\"hahha\")\n",
        "\n",
        "  dog2=Dog()\n",
        "  dog2.name=\"dahuang\"\n",
        "  dog2.age=9999\n",
        "  dog2.sit(\"wuwuuwuw\")\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Ylo-KwXbVAaA",
        "outputId": "63824d36-44ff-4752-8170-d9a8aa7d9f15"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "你调用Dog类了哦\n",
            "sharkis sitting down now hahha10\n",
            "你调用Dog类了哦\n",
            "dahuangis sitting down now wuwuuwuw9999\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 面向对象中高级\n",
        "概念：`类成员`（包括字段和方法）  \n",
        "字段：分为普通字段和静态字段：普通字段是保存在对象中的，只能通过对象来访问 ；静态字段保存在类中，既可以直接通过类来调用，也可以通过对象来调用  \n",
        "方法：分为普通方法和"
      ],
      "metadata": {
        "id": "sbfchySFZ6VD"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Province:\n",
        "  contury = \"中国\" #静态字段\n",
        "  def __init__(self, name) -> None:\n",
        "    self.name = name #普通字段\n",
        "    # pass\n",
        "\n",
        "if __name__=='__main__':\n",
        "  obj = Province(\"河北\")\n",
        "  print(obj.name) #普通字段，需要对象调用【普通字段归属于对象】\n",
        "  print(Province.contury) #静态字段，通过类调用【静态字段归属于类】\n",
        "  print(obj.contury) #静态字段，通过对象调用\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ta1wp8VjdOWe",
        "outputId": "1d2d2a68-70cd-42e5-af04-0798c604a35d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "河北\n",
            "中国\n",
            "中国\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 静态字段的优势：在内存中只会保留一份，谁需要谁调用\n",
        "举例：列出中国的几个省份，但是每个省需要加上“中国”"
      ],
      "metadata": {
        "id": "QGv-ltlXhl9D"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Province:\n",
        "  contury = \"中国\" #静态字段\n",
        "  def __init__(self, name) -> None:\n",
        "    self.name = name #普通字段\n",
        "    # pass\n",
        "\n",
        "if __name__=='__main__':\n",
        "  hebei = Province(\"河北\")\n",
        "  print(hebei.name, hebei.contury)\n",
        "\n",
        "  sichuan = Province(\"四川\")\n",
        "  print(sichuan.name, sichuan.contury)\n",
        "  \n",
        "#思考使用静态字段，同直接在__init__方法中加默认参数有什么差异呢？？其实就是内存使用的差别。如果写在默认参数中，调用一次，就会占用一次内存\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nf4SKg-1h2e_",
        "outputId": "0576d8e0-fe76-4126-8f30-3ccb14c3bf36"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "河北 中国\n",
            "四川 中国\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 接下来看方法：Python中有三种方法\n",
        "1、普通方法。普通方法都是保存在类中的  "
      ],
      "metadata": {
        "id": "jqLxnwGjkI5e"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Foo:\n",
        "  def __init__(self) -> None:\n",
        "    pass\n",
        "  def bar(self):\n",
        "    print(\"bar\")\n",
        "\n",
        "\n",
        "if __name__=='__main__':\n",
        "  #第一种调用方法的方式【类对象指针调用，可以发现前面基本都是这样调用的】\n",
        "  obj1 = Foo()\n",
        "  obj1.bar()\n",
        "\n",
        "  #第二种调用方法的方式【类直接执行方法】\n",
        "  obj2 = Foo()\n",
        "  Foo.bar(obj2) \n"
      ],
      "metadata": {
        "id": "1Mm3wlDmktEx"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# 2、静态方法：保存在类中，由类直接调用"
      ],
      "metadata": {
        "id": "7bxedRc1mD-o"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Foo:\n",
        "  def __init__(self) -> None:\n",
        "    pass\n",
        "\n",
        "  def bar(self):\n",
        "    print(\"bar\")\n",
        "\n",
        "  @staticmethod #只要加上这个装饰器，下面的方法就变成静态方法了。当成为静态方法时，self就不是必须的了，因此就可以直接调用了\n",
        "  def sta():\n",
        "    print(\"123\")\n",
        "\n",
        "if __name__=='__main__':\n",
        "  # obj = Foo()\n",
        "  # obj.sta()\n",
        "  Foo.sta() #静态方法，直接就可调用\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Rb00fB83mHKr",
        "outputId": "1bad3a8e-de67-498f-d21e-776faec6fe6d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "123\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 来一个加参数的静态方法例子"
      ],
      "metadata": {
        "id": "x8OeK-5En25_"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Foo:\n",
        "  def __init__(self) -> None:\n",
        "    pass\n",
        "\n",
        "  def bar(self):\n",
        "    print(\"bar\")\n",
        "\n",
        "  @staticmethod\n",
        "  def sta():\n",
        "    print(\"123\")\n",
        "\n",
        "  @staticmethod #给参数的静态方法\n",
        "  def book(a, b):\n",
        "    print(a, b)\n",
        "\n",
        "if __name__=='__main__':\n",
        "  # obj = Foo()\n",
        "  # obj.sta()\n",
        "  Foo.book(\"Price:\", 123)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hDvfH0BGn9xS",
        "outputId": "1f8e36a7-66b8-4b92-8872-cae3faa1e8b5"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Price: 123\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 静态方法的优势：不用创建对象就可以直接调用"
      ],
      "metadata": {
        "id": "sghaJBghoq0Z"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 3、类方法。该方法同静态方法比较类似"
      ],
      "metadata": {
        "id": "z6pqnDKgpF-P"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Foo:\n",
        "  def __init__(self) -> None:\n",
        "    pass\n",
        "\n",
        "  def bar(self):\n",
        "    print(\"bar\")\n",
        "\n",
        "  @staticmethod\n",
        "  def sta():\n",
        "    print(\"123\")\n",
        "\n",
        "  @staticmethod \n",
        "  def book(a, b):\n",
        "    print(a, b)\n",
        "\n",
        "  @classmethod #下面的方法就变成类方法了\n",
        "  def classmd(cls): #这里的cls就是类名\n",
        "    print(cls)\n",
        "    print(\"classmd\")\n",
        "\n",
        "if __name__=='__main__':\n",
        "  Foo.classmd()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_s-A-KQhpblb",
        "outputId": "1ea963df-0124-4aaa-ad13-21b9b809bdde"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<class '__main__.Foo'>\n",
            "classmd\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 应用\n",
        "如果对象中需要保存一些值，执行某功能时，需要使用对象中的值  --->   普通方法  \n",
        "不需要任何对象中的值 ---->  静态方法【其实类方法就是特殊的静态方法而已】"
      ],
      "metadata": {
        "id": "lZ3XTnLdqnKG"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Fullstack_day25_类对象：接下来讲如下内容\n",
        "1、成员修饰符；\n",
        "2、特殊成员；\n",
        "3、metaclass，类的祖宗;\n",
        "4、异常处理;\n",
        "5、反射；\n",
        "6、单列模式"
      ],
      "metadata": {
        "id": "stI9Of3p7nUj"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 成员修饰符:Python就两类：共有成员和私有成员"
      ],
      "metadata": {
        "id": "mkseg0718TOR"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Foo:\n",
        "  def __init__(self, n, a) -> None:\n",
        "    self.name = n\n",
        "    self.age = a\n",
        "\n",
        "if __name__=='__main__':\n",
        "  obj = Foo(\"alex\", 24)\n",
        "  print(obj.name)\n",
        "  print(obj.age)"
      ],
      "metadata": {
        "id": "5ThzDcaY8USr",
        "outputId": "0550e8e7-4f06-41fd-f7ce-45f8d34e820e",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "alex\n",
            "24\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "class Foo:\n",
        "  def __init__(self, n, a) -> None:\n",
        "    self.name = n\n",
        "    self.__age = a #加了\"__\"就变成私有了，外部无法访问了\n",
        "\n",
        "if __name__=='__main__':\n",
        "  obj = Foo(\"alex\", 24)\n",
        "  print(obj.name)\n",
        "  print(obj.__age) #会报错: AttributeError: 'Foo' object has no attribute '__age' 【私有，外部无法直接访问了】\n",
        "\n",
        "# 由上可知，外部无法直接访问，那我们一定要访问该怎么办呢？可以尝试如下间接访问"
      ],
      "metadata": {
        "id": "dU5SzdpB8iTO",
        "outputId": "f4775729-9926-4e9b-da13-7be3e3e5a359",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 252
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "alex\n"
          ]
        },
        {
          "output_type": "error",
          "ename": "AttributeError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-14-cda8808c289c>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      7\u001b[0m   \u001b[0mobj\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mFoo\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"alex\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m24\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      8\u001b[0m   \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 9\u001b[0;31m   \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__age\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m#会报错: AttributeError: 'Foo' object has no attribute '__age' 【私有，外部无法直接访问了】\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     10\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     11\u001b[0m \u001b[0;31m# 由上可知，外部无法直接访问，那我们一定要访问该怎么办呢？可以尝试如下间接访问\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mAttributeError\u001b[0m: 'Foo' object has no attribute '__age'"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 通过增加方法的方式来间接访问就行了\n",
        "class Foo:\n",
        "  def __init__(self, n, a) -> None:\n",
        "    self.name = n\n",
        "    self.__age = a #加了\"__\"就变成私有了，外部无法访问了\n",
        "  \n",
        "  def show(self):\n",
        "    return self.__age\n",
        "\n",
        "if __name__=='__main__':\n",
        "  obj = Foo(\"alex\", 24)\n",
        "  print(obj.show()) # 间接访问到了self.__age"
      ],
      "metadata": {
        "id": "Tbf7VGc59P3-",
        "outputId": "2f0000a1-6694-46f3-a944-c876ffb94d12",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "24\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 通过上面知道了字段分为共有和私有，那么方法呢？？也分共有和私有"
      ],
      "metadata": {
        "id": "diqvUvIT-g2n"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Foo:\n",
        "  def __init__(self) -> None:\n",
        "    pass\n",
        "  def __f1(self):\n",
        "    return 123\n",
        "  def f2(self):\n",
        "    r = self.__f1()\n",
        "    return r\n",
        "\n",
        "if __name__=='__main__':\n",
        "  obj = Foo()\n",
        "  # print(obj.__f1()) #直接是不能访问的 'Foo' object has no attribute '__f1'\n",
        "  print(obj.f2()) #写方法间接访问"
      ],
      "metadata": {
        "id": "f28OylLk-qFv",
        "outputId": "6733a2a2-5cc4-478f-f17c-3412cd64fc50",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "123\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 接下来看看继承间的情况：私有是不能继承的，还是只有间接访问\n",
        "class Father:\n",
        "  def __init__(self) -> None:\n",
        "    self.bala = 456\n",
        "    self.__haha = 123\n",
        "\n",
        "class Son(Father):\n",
        "  def __init__(self, name) -> None:\n",
        "    self.name = name\n",
        "    self.__age = 18\n",
        "    super(Son, self).__init__()\n",
        "  \n",
        "  def show(self):\n",
        "    print(self.name)\n",
        "    print(self.bala)\n",
        "    print(self.__age)\n",
        "    print(self.__haha) #父类的私有字段，是无法继承过来的，会报错\n",
        "\n",
        "if __name__=='__main__':\n",
        "  obj = Son(\"alex\")\n",
        "  print(obj.show()) "
      ],
      "metadata": {
        "id": "b3gq0IVt-y73",
        "outputId": "f8e0b803-c24d-4cab-80e9-1d876993d065",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 373
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "alex\n",
            "456\n",
            "18\n"
          ]
        },
        {
          "output_type": "error",
          "ename": "AttributeError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-17-09276798a48b>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     19\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0m__name__\u001b[0m\u001b[0;34m==\u001b[0m\u001b[0;34m'__main__'\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     20\u001b[0m   \u001b[0mobj\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mSon\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"alex\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 21\u001b[0;31m   \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;32m<ipython-input-17-09276798a48b>\u001b[0m in \u001b[0;36mshow\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m     15\u001b[0m     \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbala\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     16\u001b[0m     \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__age\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 17\u001b[0;31m     \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__haha\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m#父类的私有字段，是无法继承过来的，会报错\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     18\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     19\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0m__name__\u001b[0m\u001b[0;34m==\u001b[0m\u001b[0;34m'__main__'\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mAttributeError\u001b[0m: 'Son' object has no attribute '_Son__haha'"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "class Father:\n",
        "  def __init__(self) -> None:\n",
        "    self.bala = 456\n",
        "    self.__haha = 123\n",
        "\n",
        "  def stat(self):\n",
        "    print(self.__haha)\n",
        "\n",
        "class Son(Father):\n",
        "  def __init__(self, name) -> None:\n",
        "    self.name = name\n",
        "    self.__age = 18\n",
        "    super(Son, self).__init__()    \n",
        "  \n",
        "  def show(self):\n",
        "    print(self.name)\n",
        "    print(self.bala)\n",
        "    print(self.__age)\n",
        "    # print(self.__haha) #父类的私有字段，是无法继承过来的，会报错\n",
        "\n",
        "if __name__=='__main__':\n",
        "  obj = Son(\"alex\")\n",
        "  print(obj.stat()) #父类的私有字段，是无法继承过来，只有间接访问\n",
        "  print(obj.show())"
      ],
      "metadata": {
        "id": "QrfdCyjf_DsZ",
        "outputId": "e092257c-92f2-4603-c9be-6a3b1670f41d",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "123\n",
            "None\n",
            "alex\n",
            "456\n",
            "18\n",
            "None\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**小结：**成员分为共有和私有。想要变为私有只需加入\"__\"【两个下划线哦】。这些私有就不能直接访问了，只有采用间接访问的方式"
      ],
      "metadata": {
        "id": "0yrVPwAk_ZhB"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 接下来介绍类里边的特殊成员  __ call __ 方法【仅仅是Python的语法而已，没什么用】"
      ],
      "metadata": {
        "id": "ZGjiEYrE_fP3"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Foo:\n",
        "  def __init__(self) -> None:\n",
        "    print(\"init\")\n",
        "\n",
        "if __name__=='__main__':\n",
        "  obj = Foo() #只要一些这个，就会自动执行__init__方法。\n",
        "#但是Python中有个奇怪的地方就是，你可能遇见对象后边也加括号的代码，如下："
      ],
      "metadata": {
        "id": "A43oMld3_7q-",
        "outputId": "3e91a6d0-c88f-4cc5-b7cf-b3577f717b15",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "init\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "class Foo:\n",
        "  def __init__(self) -> None:\n",
        "    print(\"init\")\n",
        "\n",
        "if __name__=='__main__':\n",
        "  obj = Foo() \n",
        "  obj() # 如果第一次看到，肯定会觉得特别奇怪。其实这就表示执行Foo类的一个特殊方法(__call__),如果没有这个方法就会报错\n",
        "  # 这仅仅是Python中的一个规定而已，没什么具体作用，就是方便执行特殊方法(__call__)而已"
      ],
      "metadata": {
        "id": "2t1Tq_TXAA6B",
        "outputId": "45670a9a-bd2e-43d1-dea0-39a34ea7e2cd",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 235
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "init\n"
          ]
        },
        {
          "output_type": "error",
          "ename": "TypeError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-21-37ff41cec8d2>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0m__name__\u001b[0m\u001b[0;34m==\u001b[0m\u001b[0;34m'__main__'\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m   \u001b[0mobj\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mFoo\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 7\u001b[0;31m   \u001b[0mobj\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# 如果第一次看到，肯定会觉得特别奇怪。其实这就表示执行Foo类的一个特殊方法(__call__),如果没有这个方法就会报错\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      8\u001b[0m   \u001b[0;31m# 这仅仅是Python中的一个规定而已，没什么具体作用，就是方便执行特殊方法(__call__)而已\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mTypeError\u001b[0m: 'Foo' object is not callable"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "class Foo:\n",
        "  def __init__(self):\n",
        "    print(\"init\")\n",
        "  \n",
        "  def stat(self):\n",
        "    print(\"stat\")\n",
        "\n",
        "  def __call__(self):\n",
        "    print(\"call\")\n",
        "\n",
        "  @staticmethod\n",
        "  def __show__(self):\n",
        "    print(\"show\")\n",
        "\n",
        "if __name__=='__main__':\n",
        "  obj = Foo() # 自动执行__init__方法\n",
        "  obj()  #自动执行__call__方法\n",
        "  # 上面可以简单的改写为，所以代码看着更简便:\n",
        "  Foo()()"
      ],
      "metadata": {
        "id": "dCz5Q749Ahch",
        "outputId": "d08adaf9-1893-4bcd-f3f3-c8411d4bb297",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "init\n",
            "call\n",
            "init\n",
            "call\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 特殊成员__ int __ 【注意：不是__ init __方法哦】"
      ],
      "metadata": {
        "id": "c236B976AoFV"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Foo:\n",
        "  def __init__(self):\n",
        "    pass\n",
        "\n",
        "\n",
        "if __name__=='__main__':\n",
        "  obj = Foo()\n",
        "  print(obj, type(obj)) # 这样输出有个缺点，你看不出究竟是个啥东西"
      ],
      "metadata": {
        "id": "-4I8JH9DAo0-",
        "outputId": "bda17c70-8164-4157-89c4-df5fa5ec8d34",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<__main__.Foo object at 0x7ffad94e1190> <class '__main__.Foo'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "class Foo:\n",
        "  def __init__(self):\n",
        "    pass\n",
        "\n",
        "  def __int__(self):\n",
        "    print(\"int\")\n",
        "    return 111\n",
        "\n",
        "if __name__=='__main__':\n",
        "  obj = Foo()\n",
        "  print(obj, type(obj)) # 这样输出有个缺点，你看不出究竟是个啥东西\n",
        "\n",
        "  r = int(obj) # 这种会直接调用方法__int__\n",
        "  print(r)\n",
        "\n",
        "  # r = obj.__int__() #自己尝试一下，按常规出牌也是可调用的\n",
        "  # print(r)\n",
        "\n",
        "# 其实__int__方法是用的很少的，常用的时__str__方法"
      ],
      "metadata": {
        "id": "zU9OkIPMA1mf",
        "outputId": "a05eb01c-f76c-4e74-b92f-3c858cc40cdd",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<__main__.Foo object at 0x7ffad95419d0> <class '__main__.Foo'>\n",
            "int\n",
            "111\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 特殊成员__ str __方法。该方法的使用一般是打印内容"
      ],
      "metadata": {
        "id": "zok6ZYYFBwOM"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Foo:\n",
        "  def __init__(self, n, a):\n",
        "    self.name = n\n",
        "    self.age = a\n",
        "\n",
        "if __name__=='__main__':\n",
        "  obj = Foo(\"alex\", 12)\n",
        "  print(obj, type(obj)) \n",
        "\n",
        "# 不使用__str__方法，输出的结果就很难看出来真实的内容是什么"
      ],
      "metadata": {
        "id": "US5AIbIYBvj3",
        "outputId": "9d6aba31-3ae5-41e6-e05f-fa85f06cba4b",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<__main__.Foo object at 0x7ffadead47d0> <class '__main__.Foo'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "class Foo:\n",
        "  def __init__(self, n, a):\n",
        "    self.name = n\n",
        "    self.age = a\n",
        "  \n",
        "  def __str__(self):\n",
        "    # return self.name\n",
        "    return '%s-%s' %(self.name, self.age)\n",
        "\n",
        "if __name__=='__main__':\n",
        "  obj = Foo(\"alex\", 12)\n",
        "  print(obj) \n",
        "# 这时就能直接看出内容了\n",
        "# 为什么这里print就直接执行__str__方法了呢？？这就是规定"
      ],
      "metadata": {
        "id": "nAbrf0nAB73y",
        "outputId": "45478f25-1c35-4db0-a3cb-d533945a1f28",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "alex-12\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**小结：**至此已经说了4个特殊方法了哦【其实这种方法太多了，但凡是双下划线开头/结尾的,都是特殊方法】：  \n",
        "__ init __  ==》 类() ==》   自动执行  \n",
        "__ call __  ==》对象(), 类()() ==》 自动执行  \n",
        "__ int __  ==》int(对象)  ==》调用  \n",
        "__ str __  ==》print(对象） ==》调用"
      ],
      "metadata": {
        "id": "7sYsl0VbCT9v"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "a = [12, 3, 2, 5, 7]\n",
        "class Show:\n",
        "  def __init__(self, name) -> None:\n",
        "    self.name = str(name) \n",
        "    # self.name = name    # TypeError: __str__ returned non-string (type list)\n",
        "    pass\n",
        "  def __str__(self):\n",
        "    # print()\n",
        "    return self.name # 一定要为字符型\n",
        "if __name__=='__main__':\n",
        "  obj = Show(a)\n",
        "  print(obj, type(obj))\n"
      ],
      "metadata": {
        "id": "Sy0bhlibCTBW",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "0cc31071-19dd-444b-917b-66ca8c57dd1f"
      },
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[12, 3, 2, 5, 7] <class '__main__.Show'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## metaclass，类的祖宗\n",
        "1、Python中一切事物皆对象。  \n",
        "2、我们知道调用一个类的时候为obj=Foo(),这里的obj就是Foo类的一个对象，那么按照“一切事物皆对象”的原则，Foo类又是谁的对象呢？其实类都是type类的对象：\n",
        "class Foo:\n",
        "----pass  \n",
        "obj = Foo()  \n",
        "obj是Foo类的一个对象  \n",
        "其实Foo类也是一个对象，是type的对象。既其实类本身也是一个对象，是由type创建的"
      ],
      "metadata": {
        "id": "R8DfHuCrxiXc"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#伪代码:\n",
        "class Foo: # 从下面编译器真实的执行过程，可以知道，其实这里是省略了object的，应该为：class Foo(object):\n",
        "  def func(self):\n",
        "    print(\"123\")\n",
        "\n",
        "# 下面就是编译器遇到类时，真实所执行的东西\n",
        "# 这才是真实定义类的方式\n",
        "def function(self):\n",
        "  print(\"123\")\n",
        "Foo = type(\"Foo\", (object,), {'func':function}) \n",
        "obj = Foo()\n",
        "\n",
        "# 其实类的__init__方法执行之前，中间还执行了两个方法的【fullstack_day26-06讲的，有点绕，但这就是类的最难的地方了，一般知道就行】\n"
      ],
      "metadata": {
        "id": "bswD2ywo44os"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 异常处理【try一下】\n",
        "一般的格式如下\n",
        "try:  \n",
        "----代码块  \n",
        "----pass  \n",
        "except Exception as e:  \n",
        "----上述代码块出错时，执行当前代码块"
      ],
      "metadata": {
        "id": "zzlzpS68ADxK"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# 异常处理的一个最基本逻辑块\n",
        "while True:\n",
        "  try:\n",
        "    inp = input(\"请输入序号: \")\n",
        "    i = int(inp) \n",
        "  except Exception as e:\n",
        "    i = \"请输入数字\"\n",
        "  print(i) #可以发现，如果输入的东西可以用int时，就直接输出【能正常执行就输出结果】；如果输入的不能用int就会输出\"请输入数字\"【不能正常执行，就按自己的预设输出】"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 380
        },
        "id": "hEkA4771A4RR",
        "outputId": "71e04e16-f9fb-46be-becc-803f0c11615b"
      },
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "error",
          "ename": "KeyboardInterrupt",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-12-b0204776b94c>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;32mwhile\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m   \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m     \u001b[0minp\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0minput\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"请输入序号: \"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      5\u001b[0m     \u001b[0mi\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minp\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m   \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/ipykernel/kernelbase.py\u001b[0m in \u001b[0;36mraw_input\u001b[0;34m(self, prompt)\u001b[0m\n\u001b[1;32m    861\u001b[0m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_parent_ident\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    862\u001b[0m             \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_parent_header\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 863\u001b[0;31m             \u001b[0mpassword\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    864\u001b[0m         )\n\u001b[1;32m    865\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/ipykernel/kernelbase.py\u001b[0m in \u001b[0;36m_input_request\u001b[0;34m(self, prompt, ident, parent, password)\u001b[0m\n\u001b[1;32m    902\u001b[0m             \u001b[0;32mexcept\u001b[0m \u001b[0mKeyboardInterrupt\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    903\u001b[0m                 \u001b[0;31m# re-raise KeyboardInterrupt, to truncate traceback\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 904\u001b[0;31m                 \u001b[0;32mraise\u001b[0m \u001b[0mKeyboardInterrupt\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Interrupted by user\"\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    905\u001b[0m             \u001b[0;32mexcept\u001b[0m \u001b[0mException\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    906\u001b[0m                 \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlog\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwarning\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Invalid Message:\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mexc_info\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mKeyboardInterrupt\u001b[0m: Interrupted by user"
          ]
        }
      ]
    }
  ]
}