chapter10.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 序列的修改、散列和切片"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 我们将一次性实现整个vector类，使其：\n",
    "- 与vector2d类兼容\n",
    "- 构造方法可接受任意个参数，最好接受可迭代的对象作为参数\n",
    "- 支持切片\n",
    "- 实现散列\n",
    "- 将格式化显示从二维提升到多维\n",
    "- 通过特殊属性访问向量前几个分量的值"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "from array import array\n",
    "import reprlib\n",
    "import math\n",
    "import numbers\n",
    "import functools\n",
    "import operator\n",
    "import itertools\n",
    "\n",
    "\n",
    "class Vector:\n",
    "    typecode = 'd'\n",
    "\n",
    "    def __init__(self, components):\n",
    "        self._components = array(self.typecode,\n",
    "                                 components)  # 受保护的实例属性，保存Vector的分量\n",
    "\n",
    "    def __iter__(self):\n",
    "        return iter(self._components)  # 构建迭代器\n",
    "\n",
    "    def __repr__(self):\n",
    "        components = reprlib.repr(\n",
    "            self._components)  # 获取self._components的有限长度表现形式\n",
    "        components = components[components.find('['):-1]\n",
    "        return 'Vector({})'.format(components)\n",
    "\n",
    "    def __str__(self):\n",
    "        return str(tuple(self))\n",
    "\n",
    "    def __bytes__(self):\n",
    "        return (\n",
    "            bytes([ord(self.typecode)]) + bytes(self._components))  #构建bytes对象\n",
    "\n",
    "    def __eq__(self, other):  # 使用all方法来实现eq\n",
    "        return (len(self) == len(other)\n",
    "                and all(a == b for a, b in zip(self, other)))\n",
    "\n",
    "    def __hash__(self):  #实现散列函数，使用reduce来实现累计异或\n",
    "        hashes = (hash(x) for x in self)\n",
    "        return functools.reduce(operator.xor, hashes,\n",
    "                                0)  # reduce函数最好设置第三个参数，即初始值，避免出现空序列处理错误\n",
    "\n",
    "    def __abs__(self):\n",
    "        return math.sqrt(sum(x * x for x in self))\n",
    "\n",
    "    def __bool__(self):\n",
    "        return bool(abs(self))\n",
    "\n",
    "    def __len__(self):  # 鸭子类型，以支持序列操作\n",
    "        return len(self._components)\n",
    "\n",
    "    def __getitem__(self, index):  # 鸭子类型，以支持序列操作\n",
    "        cls = type(self)\n",
    "        if isinstance(index, slice):  #为了保证得到的切片也是Vector类\n",
    "            return cls(self._components[index]\n",
    "                       )  #调用类的构造方法，使用_components数组的切片构建一个新的Vector实例\n",
    "        elif isinstance(index, numbers.Integral):\n",
    "            return self._components[index]\n",
    "        else:\n",
    "            msg = '{.__name__} indices must be integers'\n",
    "            raise TypeError(msg.format(cls))\n",
    "\n",
    "    shortcut_names = 'xyzt'\n",
    "\n",
    "    def __getattr__(self, name):  #通过特殊句法读取前四个分量，__attr__方法能够在查找属性失败之后处理参数\n",
    "        cls = type(self)\n",
    "        if len(name) == 1:\n",
    "            pos = cls.shortcut_names.find(name)\n",
    "            if 0 <= pos < len(self._components):\n",
    "                return self._components[pos]\n",
    "        msg = '{.__name__!r} object has no attribute {!r}'\n",
    "        raise AttributeError(msg.format(cls, name))\n",
    "\n",
    "    def angle(self, n):\n",
    "        r = math.sqrt(sum(x * x for x in self[n:]))\n",
    "        a = math.atan2(r, self[n - 1])\n",
    "        if (n == len(self) - 1) and (self[-1] < 0):\n",
    "            return math.pi * 2 - a\n",
    "        else:\n",
    "            return a\n",
    "\n",
    "    def angles(self):\n",
    "        return (self.angle(n) for n in range(1, len(self)))\n",
    "\n",
    "    def __format__(self, fmt_spec=''):  #将Vector2d中的二维极坐标表示扩展到多维\n",
    "        if fmt_spec.endswith('h'):\n",
    "            fmt_spec = fmt_spec[:-1]\n",
    "            coords = itertools.chain([abs(self)], self.angles())\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(', '.join(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)  #把memoryview传给构造方法"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 协议和鸭子类型\n",
    "- 在Python中创建功能完善的序列类型无需使用继承，只需实现符合序列协议的方法\n",
    "- 协议时是正式的接口，只在文档中定义，在代码中不定义\n",
    "- 例如，Python的序列协议只需要```__len__```和```__getitem__```两个方法。任何类只要使用标准的签名和语义实现了这两个方法，就能用在任何期待序列的地方\n",
    "- 我们称其为序列，是因为其行为像序列，人们称其为鸭子类型"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 切片原理\n",
    "- 查看切片的index具体是如何表示的"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MySeq:\n",
    "    def __getitem__(self, index):\n",
    "        return index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = MySeq()\n",
    "s[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "slice(1, 4, None)"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[1:4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "slice(1, 4, 2)"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[1:4:2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(slice(1, 4, 2), 9)"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[1:4:2, 9]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(slice(1, 4, 2), slice(7, 9, None))"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[1:4:2, 7:9]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## indices属性\n",
    "- s.indices(len) -> (start,stop,stride)\n",
    "- 一个序列的indices属性实现了在给定长度len下，选定的切片的表示"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0, 7, 2)"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "slice(None, 10, 2).indices(7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(97, 93, -2)"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "slice(-3, -7, -2).indices(100)"
   ]
  }
 ],
 "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
}