class_learning.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "使用 class 关键字创建类"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Person:   # 创建了一个名为 Person 的类，里面有三个属性（类变量），分别是 name、age、sex\n",
    "    name = 'mike'\n",
    "    age = 20\n",
    "    sex = 'male'\n",
    "    \n",
    "p1 = Person()   # 实例化类\n",
    "print(p1.name, p1.age, p1.sex)  # 通过 类名.属性名 的方式访问类的属性"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "class 类的方法"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Person:   # 创建了一个名为 Person 的类，里面有三个属性（类变量），分别是 name、age、sex\n",
    "    name = 'mike'\n",
    "    age = 20\n",
    "    sex = 'male'\n",
    "    \n",
    "    def name_change(self, new_name):    # 添加类的方法，类的方法的形式变量一般情况下第一个形式变量必须为 self 用来表示当前实例\n",
    "        self.name = new_name    # self 表示当前实例，通过 self.属性名 来访问属性\n",
    "    \n",
    "p1 = Person()   # 实例化类\n",
    "\n",
    "p1.name_change('john')  # 对象的方法的访问使用 类名.方法名 访问\n",
    "\n",
    "print(p1.name, p1.age, p1.sex)  # 通过 类名.属性名 的方式访问类的属性"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "类变量和实例变量"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Person:   # 创建了一个名为 Person 的类，里面有三个属性（类变量），分别是 name、age、sex\n",
    "    name = 'mike'\n",
    "    age = 20\n",
    "    sex = 'male'\n",
    "    \n",
    "    def name_change(self, new_name):    # 添加类的方法，类的方法的形式变量一般情况下第一个形式变量必须为 self 用来表示当前实例\n",
    "        self.name = new_name    # self 表示当前实例，通过 self.属性名 来访问属性\n",
    "    \n",
    "    def global_name_change(self, new_name): # 方法与上面不同的地方在于，没有使用表示当前实例的 self 进行修改，而是直接使用类名\n",
    "        Person.name = new_name\n",
    "    \n",
    "p1 = Person()   # 创建对象 p1\n",
    "p2 = Person()   # 创建对象 p2\n",
    "\n",
    "p2.name_change('john')  # 将 p2 的 name 属性更改为 'john' \n",
    "\n",
    "print(p1.name, p1.age, p1.sex)  # 输出对象 p1 的属性\n",
    "print(p2.name, p2.age, p2.sex)  # 输出对象 p2 的属性"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "p2.global_name_change('john')   # 将 p2 的 name 属性更改为 'john'\n",
    "print(p1.name, p1.age, p1.sex)  # 输出对象 p1 的属性\n",
    "print(p2.name, p2.age, p2.sex)  # 输出对象 p2 的属性"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Employee:\n",
    "    '所有员工的基类'\n",
    "    empCount = 0    # 类变量，该变量在所有实例中共享\n",
    " \n",
    "    def __init__(self, name, salary):\n",
    "        self.name = name\n",
    "        self.salary = salary\n",
    "        Employee.empCount += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t1 = Employee('mike', 2000)\n",
    "t2 = Employee('sara', 2000)\n",
    "print(Employee.empCount)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "类的内置方法"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Person(object):\n",
    "    '''\n",
    "    一个关于描述人的类，具有姓名、年龄、性别三个属性\n",
    "    '''\n",
    "    \n",
    "    # __init__ 方法在类的一个对象被建立时，马上运行。这个方法可以用来对你的对象做一些你希望的初始化。注意，这个名称的开始和结尾都是双下划线。\n",
    "    # __init__ 方法可以做到在实例化对象的时候获取传入值并作为创建这个实例的参数\n",
    "    def __init__(self, name, age, sex): \n",
    "        self.name = name\n",
    "        self.age = age\n",
    "        self.sex = sex\n",
    "    \n",
    "    # __new__()在__init__()之前被调用，用于生成实例对象，它的第一个参数是这个类，其他的参数是用来直接传递给 __init__ 方法。\n",
    "    # __new__ 决定是否要使用该 __init__ 方法，因为 __new__ 可以调用其他类的构造方法或者直接返回别的实例对象来作为本类的实例\n",
    "    # 如果 __new__ 没有返回实例对象，则 __init__ 不会被调用。\n",
    "    def __new__(cls, *args, **kwd):\n",
    "        if args[1]<18:\n",
    "            raise Exception(\"未成年\")\n",
    "        else:\n",
    "            return object.__new__(cls)\n",
    "    \n",
    "    # __del__()方法：析构器，当一个实例被销毁时自动调用的方法。\n",
    "    def __del__(self): \n",
    "        print('已删除')\n",
    "    \n",
    "    # __getattribute__ 访问任意属性或方法时调用\n",
    "    def __getattribute__(self, attr):\n",
    "        print(f\"尝试获取 {attr}\")\n",
    "        return object.__getattribute__(self, attr)\n",
    "    \n",
    "    # __getattr__ 定义当用户试图获取一个不存在的属性时的行为\n",
    "    def __getattr__(self, attr):\n",
    "        print(f\"该对象不存在 {attr}\")\n",
    "    \n",
    "    # __delattr__ 删除某个属性时调用\n",
    "    def __delattr__(self, attr):\n",
    "        print(f\"正在删除该实例中的 {attr}\")\n",
    "        object.__delattr__(self, attr)\n",
    "        print(f\"已成功删除 {attr}\")\n",
    "    \n",
    "    # __setattr__ 定义当一个属性被设置时的行为\n",
    "    def __setattr__(self, name, value):\n",
    "        object.__setattr__(self, name, value)\n",
    "        print('成功添加属性{' + f'{name} : {value}' + '}')\n",
    "    \n",
    "    # 用来描述类或对象的信息，__str__用于print，结果是让人看的\n",
    "    def __str__(self):\n",
    "        return f\"__str__：这是一个 Person 类，里面有三个属性，分别是 name, age, sex，他们的值分别是 {self.name}, {self.age}, {self.sex}\"\n",
    "    \n",
    "    # 用来描述类或对象的信息，__repr__用于交互式，结果是让解释器用的\n",
    "    def __repr__(self):\n",
    "        return f\"__repr__：这是一个 Person 类，里面有三个属性，分别是 name, age, sex，他们的值分别是 {self.name}, {self.age}, {self.sex}\"\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "p1 = Person('mike', 20, 'male')\n",
    "print(p1.name, p1.age, p1.name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "p1 = Person('mike', 17, 'male')\n",
    "print(p1.name, p1.age, p1.name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 利用这个方法和类属性的特性可以实现设计模式中的单例模式单例模式是指创建唯一对象码，单例模式设计的类只能实例化一个对象.\n",
    "class Singleton(object):\n",
    "    __instance = None                       # 定义实例\n",
    "\n",
    "    def __init__(self):\n",
    "        pass\n",
    "\n",
    "    def __new__(cls, *args, **kwd):         # 在__init__之前调用\n",
    "        if Singleton.__instance is None:    # 生成唯一实例\n",
    "            Singleton.__instance = object.__new__(cls, *args, **kwd)\n",
    "        else:\n",
    "            raise Exception('!')\n",
    "        return Singleton.__instance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 也可以用于继承内置类（这是__init__所做不到的）\n",
    "class second(float):\n",
    "    \"\"\"分钟转秒\"\"\"\n",
    "    def __new__(cls, minute):\n",
    "        return float.__new__(cls, minute * 60)\n",
    "\n",
    "a = second(5) # 5分钟转为秒\n",
    "print(a) \t# 300.0\n",
    "print(a + 100)\t# 400.0 由于继承了float，所以可以直接运算，非常方便！"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "p1 = Person('mike', 20, 'male')\n",
    "del p1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "访问控制"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "p1 = Person('mike', 20, 'male')\n",
    "# __getattribute__ 访问任意属性或方法时调用\n",
    "print('\\n__getattribute__ 访问任意属性或方法时调用')\n",
    "print(p1.name)\n",
    "print(p1.__getattribute__('name'))\n",
    "# __getattr__ 定义当用户试图获取一个不存在的属性时的行为\n",
    "print('\\n__getattr__ 定义当用户试图获取一个不存在的属性时的行为')\n",
    "print(p1.location)\n",
    "# __delattr__ 删除某个属性时调用\n",
    "print('\\n__delattr__ 删除某个属性时调用')\n",
    "del p1.name\n",
    "# __setattr__ 定义当一个属性被设置时的行为\n",
    "print('\\n__setattr__ 定义当一个属性被设置时的行为')\n",
    "p1.name = 'sara'\n",
    "setattr(p1, 'sex', 'female')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "类的表示"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "p1 = Person('mike', 20, 'male')\n",
    "print(p1)\n",
    "p1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Person():\n",
    "    '''\n",
    "    一个关于描述人的类，具有姓名、年龄、性别三个属性\n",
    "    '''\n",
    "    def __init__(self, name, age, sex): \n",
    "        self.name = name\n",
    "        self.age = age\n",
    "        self.sex = sex\n",
    "\n",
    "    # 用来描述类或对象的信息，__str__用于print，结果是让人看的\n",
    "    def __str__(self):\n",
    "        return f\"__str__：这是一个 Person 类，里面有三个属性，分别是 name, age, sex，他们的值分别是 {self.name}, {self.age}, {self.sex}\"\n",
    "    \n",
    "    # 用来描述类或对象的信息，__repr__用于交互式，结果是让解释器用的\n",
    "    def __repr__(self):\n",
    "        return f\"__repr__：这是一个 Person 类，里面有三个属性，分别是 name, age, sex，他们的值分别是 {self.name}, {self.age}, {self.sex}\"\n",
    "    \n",
    "    # 当调用 bool(obj) 时，会调用 __bool__() 方法，返回 True 或 False\n",
    "    def __bool__(self):\n",
    "        return self.age==20\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "p1 = Person('mike', 20, 'male')\n",
    "p2 = Person('sara', 19, 'female')\n",
    "print(bool(p1), bool(p2))\n",
    "print(p1.__dir__())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "类的比较操作"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Person():\n",
    "    '''\n",
    "    一个关于描述人的类，具有姓名、年龄、性别三个属性\n",
    "    '''\n",
    "    def __init__(self, name, age, sex): \n",
    "        self.name = name\n",
    "        self.age = age\n",
    "        self.sex = sex\n",
    "    \n",
    "    # __eq__ 方法，可以判断两个对象是否相等\n",
    "    def __eq__(self, other):\n",
    "        return self.age == other.age\n",
    "    \n",
    "    # __ne__ 方法，可以判断两个对象是否不相等\n",
    "    def __ne__(self, other):\n",
    "        return self.age != other.age\n",
    "    \n",
    "    # __lt__ 方法，可以判断self对象小于比较目标对象\n",
    "    def __lt__(self, other):\n",
    "        return self.age < other.age\n",
    "    \n",
    "    # __gt__ 方法，可以判断self对象大于比较目标对象\n",
    "    def __gt__(self, other):\n",
    "        return self.age > other.age"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "p1 = Person('mike', 20, 'male')\n",
    "p2 = Person('sara', 19, 'female')\n",
    "print(p1==p2)\n",
    "print(p1!=p2)\n",
    "print(p1<p2)\n",
    "print(p1>p2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "容器类操作"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 这个例子实现了一个 MyList 类，在这个类中，定义了很多容器类的魔法方法。\n",
    "# 这样一来，这个 MyList 类就可以像操作普通 list 一样，通过切片的方式添加、获取、删除、迭代元素了。\n",
    "class MyList(object):\n",
    "    \"\"\"自己实现一个list\"\"\"\n",
    "\n",
    "    def __init__(self, values=None):\n",
    "        # 初始化自定义list\n",
    "        self.values = values or []\n",
    "        self._index = 0\n",
    "\n",
    "    def __setitem__(self, key, value):\n",
    "        # 添加元素\n",
    "        self.values[key] = value\n",
    "\n",
    "    def __getitem__(self, key):\n",
    "        # 获取元素\n",
    "        return self.values[key]\n",
    "\n",
    "    def __delitem__(self, key):\n",
    "        # 删除元素\n",
    "        del self.values[key]\n",
    "\n",
    "    def __len__(self):\n",
    "        # 自定义list的元素个数\n",
    "        return len(self.values)\n",
    "\n",
    "    def __iter__(self):\n",
    "        # 可迭代\n",
    "        return self\n",
    "\n",
    "    def __next__(self):\n",
    "        # 迭代的具体细节\n",
    "        # 如果__iter__返回self 则必须实现此方法\n",
    "        if self._index >= len(self.values):\n",
    "            raise StopIteration()\n",
    "        value = self.values[self._index]\n",
    "        self._index += 1\n",
    "        return value\n",
    "\n",
    "    def __contains__(self, key):\n",
    "        # 元素是否在自定义list中\n",
    "        return key in self.values\n",
    "\n",
    "    def __reversed__(self):\n",
    "        # 反转\n",
    "        return list(reversed(self.values))\n",
    "\n",
    "# 初始化自定义list\n",
    "my_list = MyList([1, 2, 3, 4, 5])\n",
    "\n",
    "# 当执行 my_list[0] 时，就会调用 __getitem__ 方法，这个方法主要用于从容器中读取元素。\n",
    "print(my_list[0])\t     # __getitem__\n",
    "# 当执行 my_list[1] = 20 时，就会调用 __setitem__ 方法，这个方法主要用于向容器内添加元素。\n",
    "my_list[1] = 20\t\t     # __setitem__\n",
    "\n",
    "# __contains__(self, item)：定义当使用成员测试运算符（in 或 not in）时的行为\n",
    "print(1 in my_list)\t     # __contains__\n",
    "# 当执行 len(my_list) 时，就会调用 __len__ 方法，这个方法主要用于读取容器内元素的数量。\n",
    "print(len(my_list))     # __len__\n",
    "\n",
    "'''\n",
    "__iter__\n",
    "\n",
    "这个方法需要重点关注，为什么我们可以执行 [i for i in my_list]？就是因为定义了 __iter__。\n",
    "这个方法的返回值可以有两种：\n",
    "\n",
    "1）返回 iter(obj)：代表使用 obj 对象的迭代协议，一般 obj 是内置的容器对象；\n",
    "2）返回 self：代表迭代的逻辑由本类来实现，此时需要重写 next 方法，实现自定义的迭代逻辑\n",
    "    在这个例子中，__iter__ 返回的是 self，所以需要定义 __next__ 方法，实现自己的迭代细节。\n",
    "    __next__ 方法使用一个索引变量，用于记录当前迭代的位置，这个方法每次被调用时，都会返回一个元素，\n",
    "    当所有元素都迭代完成后，此时 for 会停止迭代，若迭代时下标超出边界，这个方法会返回 StopIteration 异常。\n",
    "'''\n",
    "print([i for i in my_list])  # __iter__\n",
    "# 当执行 del my_list[0] 时，就会调用 __delitem__ 方法，这个方法主要用于从容器中删除元素。\n",
    "del my_list[0]\t             # __del__\n",
    "\n",
    "# 当执行 reversed(my_list) 时，就会调用 __reversed__ 方法，这个方法主要用于转置。\n",
    "reversed_list = reversed(my_list) # __reversed__\n",
    "print([i for i in reversed_list])  # __iter__\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "可调用对象"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''\n",
    "在Python中，方法也是一种高等的对象。这意味着他们也可以像其他对象一样被传递到方法中，这是一个非常惊人的特性。 \n",
    "Python中有一个特殊的魔术方法可以让类的实例的行为表现的像函数一样，你可以调用他们，将一个函数当做一个参数传到另外一个函数中等等。\n",
    "这个魔法方法就是 __call__(self, [args...])。\n",
    "'''\n",
    "class Circle(object):\n",
    "    def __init__(self, x, y):\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "\n",
    "    def __call__(self, x, y):\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "\n",
    "a = Circle(10, 20)\t # __init__\n",
    "print(a.x, a.y)\t# 10 20\n",
    "\n",
    "# 此时a这个对象可以当做一个方法来执行，这是__call__魔法方法的功劳\n",
    "a(100, 200) # 当我们这样执行时，其实它调用的就是 __call__。这样一来，我们就可以把实例当做一个方法来执行。\n",
    "print(a.x, a.y)\t # 100 200\n",
    "# 这个魔法方法通常会用在类实现一个装饰器、元类等场景中，当遇到这个魔法方法时，能理解其中的原理就可以了。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "序列化"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Person():\n",
    "    '''\n",
    "    一个关于描述人的类，具有姓名、年龄、性别三个属性\n",
    "    '''\n",
    "    def __init__(self, name, age, sex): \n",
    "        self.name = name\n",
    "        self.age = age\n",
    "        self.sex = sex\n",
    "    \n",
    "    # 当调用 pickle.dumps(person) 时，__getstate__ 方法就会被调用 \n",
    "    def __getstate__(self):\n",
    "        # 执行 pick.dumps 时 忽略 age 属性\n",
    "        return {\n",
    "            'name': self.name,\n",
    "            'sex': self.sex\n",
    "        }\n",
    "\n",
    "    # 当调用 pickle.loads(pickled_person) 时，__setstate__ 会被调用，其中传入的参数就是 __getstate__ 返回的结果\n",
    "    def __setstate__(self, state):\n",
    "        # 执行 pick.loads 时 忽略 age 属性\n",
    "        self.name = state['name']\n",
    "        self.sex = state['sex']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pickle\n",
    "\n",
    "person = Person('mike', 20, 'male')\n",
    "pickled_person = pickle.dumps(person) # 自动执行 __getstate__ 方法\n",
    "\n",
    "p = pickle.loads(pickled_person) # 自动执行 __setstate__ 方法\n",
    "print(p.name, p.sex)\n",
    "# 由于执行 pick.loads 时 忽略 age 属性，所以下面执行回报错\n",
    "print(p.age)  # AttributeError: 'Person' object has no attribute 'age'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''\n",
    "当定义扩展类型时（也就是使用Python的C语言API实现的类型），如果你想pickle它们，你必须告诉Python如何pickle它们。\n",
    "__reduce__ 被定义之后，当对象被Pickle时就会被调用。\n",
    "它要么返回一个代表全局名称的字符串，Pyhton会查找它并pickle，要么返回一个元组。\n",
    "这个元组包含2到5个元素，其中包括：\n",
    "    一个可调用的对象，用于重建对象时调用；\n",
    "    一个参数元素，供那个可调用对象使用；被传递给 __setstate__ 的状态（可选）；\n",
    "    一个产生被pickle的列表元素的迭代器（可选）；一个产生被pickle的字典元素的迭代器（可选）\n",
    "'''\n",
    "class Person():\n",
    "    '''\n",
    "    一个关于描述人的类，具有姓名、年龄、性别三个属性\n",
    "    '''\n",
    "    def __init__(self, name, age, sex): \n",
    "        self.name = name\n",
    "        self.age = age\n",
    "        self.sex = sex\n",
    "    \n",
    "    def __call__(self, *args):\n",
    "        return Person(args)\n",
    "    \n",
    "    def __reduce__(self):\n",
    "        print('?')\n",
    "        return (Person, (self.name, self.age, self.sex))\n",
    "    \n",
    "p1 = Person('mike', 20, 'male')\n",
    "pickled_person = pickle.dumps(p1)\n",
    "p = pickle.loads(pickled_person)\n",
    "print(p.name, p.age, p.sex)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "其他"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "p1.__hash__()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Timeshow:\n",
    "    def __init__(self, year,mon, day):\n",
    "        self.year = year\n",
    "        self.mon = mon\n",
    "        self.day = day\n",
    " \n",
    "    format_dic={\n",
    "        \"ymd\":\"{0.year}{0.mon}{0.day}\",\n",
    "        \"y:m:d\":\"{0.year}:{0.mon}:{0.day}\",\n",
    "        \"y-m-d\":\"{0.year}-{0.mon}-{0.day}\",\n",
    "        \"m-d-y\":\"{0.mon}-{0.day}-{0.year}\"\n",
    "    }\n",
    " \n",
    "    def __format__(self, format_spec):\n",
    "        if not format_spec:#这个判断分支，主要是当没有传入format_spec参数时，即给输出默认格式\n",
    "            return \"{0.year}{0.mon}{0.day}\".format(self)\n",
    "        else:\n",
    "            format_geshi=self.format_dic[format_spec]#如果传了ormat_spec参数，就根据上面定义的format_dic去找到格式，输出\n",
    "            return format_geshi.format(self)\n",
    " \n",
    " \n",
    "t=Timeshow(2018,\"01\",\"01\")\n",
    "print(t.__format__(\"y:m:d\"))\n",
    "print(format(t,\"m-d-y\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "p1.__sizeof__()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''\n",
    "示例中，当有子类继承了 Philosopher ，那么 __init_subclass__ 就会调用。\n",
    "内容也很简单，父类 Philosopher 为它的所有子类都设置了 default_name 属性。\n",
    "'''\n",
    "class Philosopher:\n",
    "    def __init_subclass__(cls, default_name, **kwargs):\n",
    "        super().__init_subclass__(**kwargs)\n",
    "        cls.default_name = default_name\n",
    "\n",
    "class AustralianPhilosopher(Philosopher, default_name=\"Bruce\"):\n",
    "    pass\n",
    "\n",
    "o = Philosopher()\n",
    "s = AustralianPhilosopher()\n",
    "print(s.default_name)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Person:\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "    @staticmethod\n",
    "    def hi():\n",
    "        print('hi')\n",
    "    def sayHi(self):\n",
    "        print('Hello, my name is', self.name)\n",
    "p = Person('Swaroop')\n",
    "p.sayHi()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Person.hi()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Person.sayHi()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "内置属性"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Person():\n",
    "    '''\n",
    "    一个关于描述人的类，具有姓名、年龄、性别三个属性\n",
    "    '''\n",
    "    \n",
    "    # __init__ 方法在类的一个对象被建立时，马上运行。这个方法可以用来对你的对象做一些你希望的初始化。注意，这个名称的开始和结尾都是双下划线。\n",
    "    # __init__ 方法可以做到在实例化对象的时候获取传入值并作为创建这个实例的参数\n",
    "    def __init__(self, name, age, sex): \n",
    "        self.name = name\n",
    "        self.age = age\n",
    "        self.sex = sex\n",
    "    \n",
    "    @staticmethod\n",
    "    def hi():\n",
    "        print('hi')\n",
    "        \n",
    "    def sayHi(self):\n",
    "        print('Hello, my name is', self.name)\n",
    "\n",
    "p1 = Person('mike', 20, 'male')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(p1.__class__)\n",
    "p2 = p1.__class__('sara', 19, 'female') # Person('sara', 19, 'female')\n",
    "print(p2)\n",
    "print(p2.name, p2.age, p2.sex)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(p1.__doc__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(p1.__dict__)\n",
    "print(Person.__dict__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Person():\n",
    "    '''\n",
    "    一个关于描述人的类，具有姓名、年龄、性别三个属性\n",
    "    '''\n",
    "    \n",
    "    __slots__ = ('name', 'age', 'sex')\n",
    "    \n",
    "    # __init__ 方法在类的一个对象被建立时，马上运行。这个方法可以用来对你的对象做一些你希望的初始化。注意，这个名称的开始和结尾都是双下划线。\n",
    "    # __init__ 方法可以做到在实例化对象的时候获取传入值并作为创建这个实例的参数\n",
    "    def __init__(self, name, age, sex): \n",
    "        self.name = name\n",
    "        self.age = age\n",
    "        self.sex = sex\n",
    "\n",
    "p1 = Person('mike', 20, 'male')\n",
    "p1.name = 'sara'\n",
    "print('当添加不在__slots__元组内的属性的时候会报错')\n",
    "p1.location = 'shanghai'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Person():\n",
    "    '''\n",
    "    一个关于描述人的类，具有姓名、年龄、性别三个属性\n",
    "    '''\n",
    "    # __init__ 方法在类的一个对象被建立时，马上运行。这个方法可以用来对你的对象做一些你希望的初始化。注意，这个名称的开始和结尾都是双下划线。\n",
    "    # __init__ 方法可以做到在实例化对象的时候获取传入值并作为创建这个实例的参数\n",
    "    def __init__(self, name, age, sex): \n",
    "        self.name = name\n",
    "        self.age = age\n",
    "        self.sex = sex\n",
    "p1 = Person('mike', 20, 'male')\n",
    "p1.location = 'shanghai'\n",
    "# 当没有__slots__的时候可以添加不存在于__slots__内的属性"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.7.0 ('base')",
   "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.0"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "ec3b6344b8b3f6c3db1463248c46b8920f4fc68f6187e2c1e71f56a52299e245"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}