week10/9.符合Python风格的对象.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 第9章 符合Python风格的对象\n",
    "得益于Python的数据类型, 自定义类型可以像内置类型那样自然。实现如此自然的行为, 靠的不是继承, 而是鸭子类型(duck typing)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 9.1 对象表示形式\n",
    "Python提供了两种表示形式:repr(), str()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 9.2 再谈向量类"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "from array import array\n",
    "import math\n",
    "# 自己设计向量类v0\n",
    "class Vector2d(object):\n",
    "    typecode = \"d\"\n",
    "    \n",
    "    def __init__(self, x, y):\n",
    "        self.x = float(x)\n",
    "        self.y = float(y)\n",
    "        \n",
    "    def __iter__(self):\n",
    "        return (i for i in (self.x, self.y))\n",
    "    \n",
    "    def __repr__(self):\n",
    "        class_name = type(self).__name__\n",
    "        return \"{}({!r}, {!r})\".format(class_name, *self)  # 实现了iter就会自动拆包\n",
    "    \n",
    "    def __str__(self):\n",
    "        return str(tuple(self)) # 实现了iter方法\n",
    "    \n",
    "    def __bytes__(self):\n",
    "        return (bytes([ord(self.typecode)]) + bytes(array(self.typecode, self)))\n",
    "    \n",
    "    def __eq__(self, other):\n",
    "        return tuple(self) == tuple(self)\n",
    "    \n",
    "    def __abs__(self):\n",
    "        return math.hypot(self.x, self.y)\n",
    "    \n",
    "    def __bool__(self):\n",
    "        return bool(self.x or self.y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3.0, 4.0)\n"
     ]
    }
   ],
   "source": [
    "v1 = Vector2d(3, 4)\n",
    "print(v1)  # 调用str方法"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3.0, 4.0)"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x, y = v1\n",
    "x, y  # 拆包"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Vector2d(3.0, 4.0)"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    " v1  # 调用repr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Vector2d(3.0, 4.0)"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v1_clone = eval(repr(v1))\n",
    "v1_clone"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "b'd\\x00\\x00\\x00\\x00\\x00\\x00\\x08@\\x00\\x00\\x00\\x00\\x00\\x00\\x10@'"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "octets = bytes(v1)\n",
    "octets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.0"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "abs(v1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bool(v1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 9.3 备选构造方法\n",
    "使用frombytes方法来实现反序列化"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "from array import array\n",
    "import math\n",
    "# 自己设计向量类v1\n",
    "class Vector2d(object):\n",
    "    typecode = \"d\"\n",
    "    \n",
    "    def __init__(self, x, y):\n",
    "        self.x = float(x)\n",
    "        self.y = float(y)\n",
    "        \n",
    "    def __iter__(self):\n",
    "        return (i for i in (self.x, self.y))\n",
    "    \n",
    "    def __repr__(self):\n",
    "        class_name = type(self).__name__\n",
    "        return \"{}({!r}, {!r})\".format(class_name, *self)  # 实现了iter就会自动拆包\n",
    "    \n",
    "    def __str__(self):\n",
    "        return str(tuple(self)) # 实现了iter方法\n",
    "    \n",
    "    def __bytes__(self):\n",
    "        return (bytes([ord(self.typecode)]) + bytes(array(self.typecode, self)))\n",
    "    \n",
    "    def __eq__(self, other):\n",
    "        return tuple(self) == tuple(self)\n",
    "    \n",
    "    def __abs__(self):\n",
    "        return math.hypot(self.x, self.y)\n",
    "    \n",
    "    def __bool__(self):\n",
    "        return bool(self.x or self.y)\n",
    "    \n",
    "    @classmethod\n",
    "    def frombytes(cls, octets):\n",
    "        cls.typecode = chr(octets[0])\n",
    "        memv = memoryview(octets[1:]).cast(cls.typecode)\n",
    "        return cls(*memv)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Vector2d(3.0, 4.0)"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v = Vector2d.frombytes(bytes(v1))\n",
    "v"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 9.4 classmethod与staticmethod\n",
    "后者就是定义在类中的普通方法"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 9.5 格式化显示\n",
    "内置的format()函数和str.format()方法把各个类型的格式化方式委托给相应的\\_\\_format\\_\\_(format\\_spec)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.4115226337448559"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "brl = 1/2.43\n",
    "brl"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'0.4115'"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "format(brl, \"0.4f\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'1 BRL = 0.41 USD'"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"1 BRL = {rate:0.2f} USD\".format(rate=brl)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "from datetime import datetime"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "datetime.datetime(2020, 8, 30, 10, 24, 26, 261079)"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "now = datetime.now()\n",
    "now"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'10:24:26'"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "format(now, \"%H:%M:%S\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如果类中没有定义\\_\\_format\\_\\_方法, 从object继承的方法会返回str(my_object)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'(3.0, 4.0)'"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "format(v1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unsupported format string passed to Vector2d.__format__",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-57-4389c670876e>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\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;32m----> 2\u001b[0;31m \u001b[0mformat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mv1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\".2f\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: unsupported format string passed to Vector2d.__format__"
     ]
    }
   ],
   "source": [
    "# 但是这个时候如果传入格式说明就会报错\n",
    "format(v1, \".2f\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "from array import array\n",
    "import math\n",
    "# 自己设计向量类v2\n",
    "class Vector2d(object):\n",
    "    typecode = \"d\"\n",
    "    \n",
    "    def __init__(self, x, y):\n",
    "        self.x = float(x)\n",
    "        self.y = float(y)\n",
    "        \n",
    "    def __iter__(self):\n",
    "        return (i for i in (self.x, self.y))\n",
    "    \n",
    "    def __repr__(self):\n",
    "        class_name = type(self).__name__\n",
    "        return \"{}({!r}, {!r})\".format(class_name, *self)  # 实现了iter就会自动拆包\n",
    "    \n",
    "    def __str__(self):\n",
    "        return str(tuple(self)) # 实现了iter方法\n",
    "    \n",
    "    def __bytes__(self):\n",
    "        return (bytes([ord(self.typecode)]) + bytes(array(self.typecode, self)))\n",
    "    \n",
    "    def __eq__(self, other):\n",
    "        return tuple(self) == tuple(self)\n",
    "    \n",
    "    def __abs__(self):\n",
    "        return math.hypot(self.x, self.y)\n",
    "    \n",
    "    def __bool__(self):\n",
    "        return bool(self.x or self.y)\n",
    "    \n",
    "    @classmethod\n",
    "    def frombytes(cls, octets):\n",
    "        cls.typecode = chr(octets[0])\n",
    "        memv = memoryview(octets[1:]).cast(cls.typecode)\n",
    "        return cls(*memv)\n",
    "    \n",
    "    def __format__(self, fmt_spec=''):\n",
    "        componets = (format(c, fmt_spec) for c in self)\n",
    "        return \"({}, {})\".format(*componets)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'(3.00, 4.00)'"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v1 = Vector2d(3,4)\n",
    "format(v1, \".2f\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 9.6 可散列的Vector2d\n",
    "为了能够散列Vector2d, 就必须实现\\_\\_hash\\_\\_方法。\n",
    "\n",
    "并且可以让x,y属性变为只读"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "from array import array\n",
    "import math\n",
    "# 自己设计向量类v2\n",
    "class Vector2d(object):\n",
    "    typecode = \"d\"\n",
    "    \n",
    "    def __init__(self, x, y):\n",
    "        self.__x = float(x)\n",
    "        self.__y = float(y)\n",
    "        \n",
    "    @property    \n",
    "    def x(self):\n",
    "        return self.__x\n",
    "    \n",
    "    @property\n",
    "    def y(self):\n",
    "        return self.__y\n",
    "    \n",
    "    def __iter__(self):\n",
    "        return (i for i in (self.x, self.y))\n",
    "    \n",
    "    def __repr__(self):\n",
    "        class_name = type(self).__name__\n",
    "        return \"{}({!r}, {!r})\".format(class_name, *self)  # 实现了iter就会自动拆包\n",
    "    \n",
    "    def __str__(self):\n",
    "        return str(tuple(self)) # 实现了iter方法\n",
    "    \n",
    "    def __bytes__(self):\n",
    "        return (bytes([ord(self.typecode)]) + bytes(array(self.typecode, self)))\n",
    "    \n",
    "    def __eq__(self, other):\n",
    "        return tuple(self) == tuple(self)\n",
    "    \n",
    "    def __abs__(self):\n",
    "        return math.hypot(self.x, self.y)\n",
    "    \n",
    "    def __bool__(self):\n",
    "        return bool(self.x or self.y)\n",
    "    \n",
    "    @classmethod\n",
    "    def frombytes(cls, octets):\n",
    "        cls.typecode = chr(octets[0])\n",
    "        memv = memoryview(octets[1:]).cast(cls.typecode)\n",
    "        return cls(*memv)\n",
    "    \n",
    "    def __format__(self, fmt_spec=''):\n",
    "        componets = (format(c, fmt_spec) for c in self)\n",
    "        return \"({}, {})\".format(*componets)\n",
    "    \n",
    "    def __hash__(self):  # 只有不可变的属性才能hash\n",
    "        return hash(self.x) ^ hash(self.y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [],
   "source": [
    "v1 = Vector2d(3, 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Vector2d(3.0, 4.0)"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hash(v1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 9.7 Python的私有属性和“受保护的”属性\n",
    "Python的单下划线为保护变量机制是程序员约定俗成的, Python解释器并不会做什么保护机制。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'_Vector2d__x': 3.0, '_Vector2d__y': 4.0}"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v1.__dict__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 9.8 使用\\_\\_slots\\_\\_类属性节省空间\n",
    "默认情况下, Python的各个实例中名为\\_\\_dict\\_\\_的字典储存实例属性以提升访问速度。但是为了结省内存, 我们可以使用\\_\\_slots\\_\\_类属性,\n",
    "\n",
    "用元组去保存实例属性，而不用字典。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Vector2d:\n",
    "    \n",
    "    def __init__(self, x, y):\n",
    "        self.x = x\n",
    "        self.y = y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "mappingproxy({'__module__': '__main__',\n",
       "              '__init__': <function __main__.Vector2d.__init__(self, x, y)>,\n",
       "              '__dict__': <attribute '__dict__' of 'Vector2d' objects>,\n",
       "              '__weakref__': <attribute '__weakref__' of 'Vector2d' objects>,\n",
       "              '__doc__': None})"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Vector2d.__dict__  # 注意这里是类的dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'x': 3, 'y': 4}"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v = Vector2d(3, 4)\n",
    "v.__dict__  # 这是实例的dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 使用slots\n",
    "class Vector2d:\n",
    "    __slots__ = (\"__x\", \"__y\")  # 告诉解释器, 这个类的所有实例属性都在这里\n",
    "    \n",
    "    def __init__(self, x, y):\n",
    "        self.__x = x\n",
    "        self.__y = y\n",
    "    \n",
    "    @property\n",
    "    def x(self):\n",
    "        return self.__x\n",
    "    \n",
    "    @property\n",
    "    def y(self):\n",
    "        return self.__y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [],
   "source": [
    "v = Vector2d(3, 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'Vector2d' object has no attribute '__dict__'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-106-1190874a5fba>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mv\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__dict__\u001b[0m  \u001b[0;31m# 这时候就没有__dict__\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m: 'Vector2d' object has no attribute '__dict__'"
     ]
    }
   ],
   "source": [
    "v.__dict__  # 这时候就没有__dict__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['_Vector2d__x',\n",
       " '_Vector2d__y',\n",
       " '__class__',\n",
       " '__delattr__',\n",
       " '__dir__',\n",
       " '__doc__',\n",
       " '__eq__',\n",
       " '__format__',\n",
       " '__ge__',\n",
       " '__getattribute__',\n",
       " '__gt__',\n",
       " '__hash__',\n",
       " '__init__',\n",
       " '__init_subclass__',\n",
       " '__le__',\n",
       " '__lt__',\n",
       " '__module__',\n",
       " '__ne__',\n",
       " '__new__',\n",
       " '__reduce__',\n",
       " '__reduce_ex__',\n",
       " '__repr__',\n",
       " '__setattr__',\n",
       " '__sizeof__',\n",
       " '__slots__',\n",
       " '__str__',\n",
       " '__subclasshook__',\n",
       " 'x',\n",
       " 'y']"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dir(v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [],
   "source": [
    "class A:\n",
    "    __slots__= (\"ax\", \"ay\")\n",
    "    \n",
    "    def __init__(self, ax, ay):\n",
    "        self.ax = ax\n",
    "        self.ay = ay\n",
    "        \n",
    "class B(A):\n",
    "    __slots__= (\"bx\", \"by\")\n",
    "    \n",
    "    def __init__(self, bx, by):\n",
    "        super().__init__(bx, by)\n",
    "        self.bx = bx\n",
    "        self.by = by \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 2)"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = B(1, 2)\n",
    "x.ax, x.ay"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 2)"
      ]
     },
     "execution_count": 123,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.bx, x.by"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如果用了slots还要用弱引用就需要把weakref添加到slots中"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "slots需要注意的点：\n",
    "* 每个子类都需要定义slots, 因为解释器会忽略继承的slots\n",
    "* 实例只能拥有slots中列出的属性\n",
    "* 要想用弱引用就需要把weakref添加到slots中"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 9.9 覆盖类属性"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 使用slots\n",
    "class Vector2d:\n",
    "    typecode = \"d\"\n",
    "    \n",
    "    def __init__(self, x, y):\n",
    "        self.__x = x\n",
    "        self.__y = y\n",
    "    \n",
    "    @property\n",
    "    def x(self):\n",
    "        return self.__x\n",
    "    \n",
    "    @property\n",
    "    def y(self):\n",
    "        return self.__y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [],
   "source": [
    "v = Vector2d(3, 4)\n",
    "v.typecode = \"f\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'d'"
      ]
     },
     "execution_count": 126,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Vector2d.typecode  #不会被改变"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'f'"
      ]
     },
     "execution_count": 127,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v.typecode"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "tensorflow2",
   "language": "python",
   "name": "tensorflow2"
  },
  "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.6.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}