chapter9.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "toc-hr-collapsed": false
   },
   "source": [
    "# 符合Python风格的对象"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 我们实现一个类，使其和内置类型那样自然\n",
    "- 实现repr()和str()方法\n",
    "- 实现eq()和bytes()方法"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from array import array\n",
    "import math\n",
    "\n",
    "\n",
    "class Vector2d:\n",
    "    \"\"\"\n",
    "        >>> v1 = Vector2d(3, 4)\n",
    "        >>> print(v1.x, v1.y)  # <1>\n",
    "        3.0 4.0\n",
    "        >>> x, y = v1  # <2>\n",
    "        >>> x, y\n",
    "        (3.0, 4.0)\n",
    "        >>> v1  # <3>\n",
    "        Vector2d(3.0, 4.0)\n",
    "        >>> v1_clone = eval(repr(v1))  # <4>\n",
    "        >>> v1 == v1_clone  # <5>\n",
    "        True\n",
    "        >>> print(v1)  # <6>\n",
    "        (3.0, 4.0)\n",
    "        >>> octets = bytes(v1)  # <7>\n",
    "        >>> octets\n",
    "        b'd\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x08@\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x00\\\\x10@'\n",
    "        >>> abs(v1)  # <8>\n",
    "        5.0\n",
    "        >>> bool(v1), bool(Vector2d(0, 0))  # <9>\n",
    "        (True, False)\n",
    "    \"\"\"\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)\n",
    "\n",
    "    def __str__(self):\n",
    "        return str(tuple(self))\n",
    "\n",
    "    def __bytes__(self):\n",
    "        return (\n",
    "            bytes([ord(self.typecode)]) + bytes(array(self.typecode, self)))\n",
    "\n",
    "    def __eq__(self, other):\n",
    "        return tuple(self) == tuple(other)\n",
    "\n",
    "    def __abs__(self):\n",
    "        return math.hypot(self.x, self.y)\n",
    "\n",
    "    def __bool__(self):\n",
    "        return bool(abs(self))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## classmethod与staticmethod"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## classmethod定义操作类\n",
    "- 改变了调用方法的方式\n",
    "- 类方法的第一个参数是类本身"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## staticmethod定义静态类方法\n",
    "- 不需要传入类对象"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(__main__.Demo,)"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Demo:\n",
    "    @classmethod\n",
    "    def klassmeth(*args):\n",
    "        return args\n",
    "\n",
    "    @staticmethod\n",
    "    def statmeth(*args):\n",
    "        return args\n",
    "\n",
    "\n",
    "Demo.klassmeth()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(__main__.Demo, 'spam')"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Demo.klassmeth('spam')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Demo.statmeth()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('spam',)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Demo.statmeth('spam')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 格式化显示\n",
    "- 为我们的Vector2d类添加格式化显示，根据用户传入的参数进行格式化，实现__format__方法\n",
    "- 同时添加自定义的格式化显示，例如根据特殊参数来显示极坐标下的坐标\n",
    "- 相比之前的版本1，我们还实现了一个classmethod，用于从bytes中恢复对象"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "from array import array\n",
    "import math\n",
    "\n",
    "\n",
    "class Vector2dv2:\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)\n",
    "\n",
    "    def __str__(self):\n",
    "        return str(tuple(self))\n",
    "\n",
    "    def __bytes__(self):\n",
    "        return (\n",
    "            bytes([ord(self.typecode)]) + bytes(array(self.typecode, self)))\n",
    "\n",
    "    def __eq__(self, other):\n",
    "        return tuple(self) == tuple(other)\n",
    "\n",
    "    def __abs__(self):\n",
    "        return math.hypot(self.x, self.y)\n",
    "\n",
    "    def __bool__(self):\n",
    "        return bool(abs(self))\n",
    "\n",
    "    def angle(self):\n",
    "        return math.atan2(self.y, self.x)\n",
    "\n",
    "    def __format__(self, fmt_spec=''):\n",
    "        if fmt_spec.endswith('p'):\n",
    "            fmt_spec = fmt_spec[:-1]\n",
    "            coords = (abs(self), self.angle())\n",
    "            outer_fmt = '<{}, {}>'\n",
    "        else:\n",
    "            coords = self\n",
    "            outer_fmt = '({}, {})'\n",
    "        components = (format(c, fmt_spec) for c in coords)\n",
    "        return outer_fmt.format(*components)\n",
    "\n",
    "    @classmethod\n",
    "    def frombytes(cls, octets):\n",
    "        typecode = chr(octets[0])\n",
    "        memv = memoryview(octets[1:]).cast(typecode)\n",
    "        return cls(*memv)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 添加散列函数\n",
    "- 使得Vector2d对象可以添加进几何中，需要实现__hash__方法。我们将使用异或运算符来混合各分量的散列值\n",
    "- 若要实现散列，则需保证向量不可变（使用@property装饰器，见19章）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Vector2dv3:\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)\n",
    "\n",
    "    def __str__(self):\n",
    "        return str(tuple(self))\n",
    "\n",
    "    def __bytes__(self):\n",
    "        return (\n",
    "            bytes([ord(self.typecode)]) + bytes(array(self.typecode, self)))\n",
    "\n",
    "    def __eq__(self, other):\n",
    "        return tuple(self) == tuple(other)\n",
    "\n",
    "    def __hash__(self):\n",
    "        return hash(self.x) ^ hash(self.y)\n",
    "\n",
    "    def __abs__(self):\n",
    "        return math.hypot(self.x, self.y)\n",
    "\n",
    "    def __bool__(self):\n",
    "        return bool(abs(self))\n",
    "\n",
    "    def angle(self):\n",
    "        return math.atan2(self.y, self.x)\n",
    "\n",
    "    def __format__(self, fmt_spec=''):\n",
    "        if fmt_spec.endswith('p'):\n",
    "            fmt_spec = fmt_spec[:-1]\n",
    "            coords = (abs(self), self.angle())\n",
    "            outer_fmt = '<{}, {}>'\n",
    "        else:\n",
    "            coords = self\n",
    "            outer_fmt = '({}, {})'\n",
    "        components = (format(c, fmt_spec) for c in coords)\n",
    "        return outer_fmt.format(*components)\n",
    "\n",
    "    @classmethod\n",
    "    def frombytes(cls, octets):\n",
    "        typecode = chr(octets[0])\n",
    "        memv = memoryview(octets[1:]).cast(typecode)\n",
    "        return cls(*memv)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python的私有属性和受保护属性\n",
    "- Python不具有private修饰符，但可以使用名称改写防止继承的子类覆盖父类的属性\n",
    "- 用两个下划线开头命名实例属性来进行名称改写，可以查看__dict__，发现属性名加上了类名作为前缀"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.0\n"
     ]
    },
    {
     "ename": "AttributeError",
     "evalue": "can't set attribute",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-4-89c5425828e7>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[0mv1\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m__dict__\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mv1\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mx\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 4\u001b[1;33m \u001b[0mv1\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mx\u001b[0m \u001b[1;33m=\u001b[0m\u001b[1;36m3\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m: can't set attribute"
     ]
    }
   ],
   "source": [
    "v1 = Vector2dv3(3, 4)\n",
    "v1.__dict__\n",
    "print(v1.x)\n",
    "v1.x =3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 依然可以读取到属性值，因此只是起保护作用而不是安全"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.0"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v1._Vector2dv3__x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 使用__slots__类属性来节省空间\n",
    "- slots使用了散列表，而不是```self.__dict__```中的词典，节省内存\n",
    "- 使用了slots之后不能让类的用户新增实例属性"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "class Vector2d:\n",
    "    __slots__ = ('__x', '__y')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 覆盖类属性\n",
    "- 注意到Vector2d中typecode是类属性而不是实例属性，我们可以用类属性为实例属性提供默认值，例如在类方法bytes中做的那样\n",
    "- 为不存在的实例属性复制，会新建实例属性：\n",
    "    - 我们使用self.typecode实际上是类属性typecode，但是之后self.typecode便实例化，成为实例属性\n",
    "    - 因此我们可以在实例化一个类对象之后，修改类属性，调用bytes方法时其实例属性便也发生更改，因此可以为各个实例的typecode属性定制不同值"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b'd\\x9a\\x99\\x99\\x99\\x99\\x99\\xf1?\\x9a\\x99\\x99\\x99\\x99\\x99\\x01@'\n"
     ]
    }
   ],
   "source": [
    "v2 = Vector2dv3(1.1, 2.2)\n",
    "print(bytes(v2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b'f\\xcd\\xcc\\x8c?\\xcd\\xcc\\x0c@'\n"
     ]
    }
   ],
   "source": [
    "v2.typecode = 'f'\n",
    "print(bytes(v2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'d'"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Vector2dv3.typecode"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "toc-hr-collapsed": true
   },
   "source": [
    "## 当想为整个类修改类属性的默认值时\n",
    "- 一般是创建一个子类，只修改类数据属性"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ShortVector2d(Vector2dv3):\n",
    "    typecode = '\n",
    "    f'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b'f\\x8c.\\xba=&\\xb4\\x17='\n"
     ]
    }
   ],
   "source": [
    "sv = ShortVector2d(1 / 11, 1 / 27)\n",
    "print(bytes(sv))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.1"
  },
  "latex_envs": {
   "LaTeX_envs_menu_present": true,
   "autoclose": false,
   "autocomplete": true,
   "bibliofile": "biblio.bib",
   "cite_by": "apalike",
   "current_citInitial": 1,
   "eqLabelWithNumbers": true,
   "eqNumInitial": 1,
   "hotkeys": {
    "equation": "Ctrl-E",
    "itemize": "Ctrl-I"
   },
   "labels_anchors": false,
   "latex_user_defs": false,
   "report_style_numbering": false,
   "user_envs_cfg": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}