09-pythonic-obj.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 符合 Python 风格的对象\n",
    "> 绝对不要使用两个前导下划线，这是很烦人的自私行为。  \n",
    "> ——Ian Bicking  \n",
    ">   pip, virtualenv 和 Paste 等项目的创建者\n",
    "\n",
    "得益于 Python 数据模型，自定义类型的行为可以像内置类型那样自然。  \n",
    "实现如此自然的行为，靠的不是继承，而是**鸭子类型**（duck typing）：我们只需按照预定行为实现对象所需的方法即可。\n",
    "\n",
    "当然，这些方法不是必须要实现的，我们需要哪些功能，再去实现它就好。\n",
    "\n",
    "书中的 `Vector` 类完整实现可见[官方 Repo](/~https://github.com/fluentpython/example-code/blob/master/09-pythonic-obj/vector2d_v3.py)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 对象表现形式\n",
    "Python 中，有两种获取对象的字符串表示形式的标准方式：\n",
    "* `repr()`：以便于开发者理解的方式返回对象的字符串表示形式\n",
    "* `str()`：以便于用户理解的方式返回对象的字符串表示形式\n",
    "\n",
    "实现 `__repr__` 和 `__str__` 两个特殊方法，可以分别为 `repr` 和 `str` 提供支持。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## classmethod & staticmethod\n",
    "`classmethod`: 定义操作**类**，而不是操作**实例**的方法。  \n",
    "`classmethod` 最常见的用途是定义备选构造方法，比如 `datetime.fromordinal` 和 `datetime.fromtimestamp`.\n",
    "\n",
    "`staticmethod` 也会改变方法的调用方式，但方法的第一个参数不是特殊的值（`self` 或 `cls`）。  \n",
    "`staticmethod` 可以把一些静态函数定义在类中而不是模块中，但抛开 `staticmethod`，我们也可以用其它方法来实现相同的功能。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(<class '__main__.Demo'>, 1) (1,)\n",
      "(<class '__main__.Demo'>, 1) (1,) (<__main__.Demo object at 0x05E719B0>, 1)\n"
     ]
    }
   ],
   "source": [
    "class Demo:\n",
    "    def omethod(*args):\n",
    "        # 第一个参数是 Demo 对象\n",
    "        return args\n",
    "    @classmethod\n",
    "    def cmethod(*args):\n",
    "        # 第一个参数是 Demo 类\n",
    "        return args\n",
    "    @staticmethod\n",
    "    def smethod(*args):\n",
    "        # 第一个参数不是固定的，由调用者传入\n",
    "        return args\n",
    "\n",
    "print(Demo.cmethod(1), Demo.smethod(1))\n",
    "demo = Demo()\n",
    "print(demo.cmethod(1), demo.smethod(1), demo.omethod(1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 字符串模板化\n",
    "`__format__` 实现了 `format` 方法的接口，它的参数为 `format` 格式声明符，格式声明符的表示法叫做[格式规范微语言](https://docs.python.org/3/library/string.html#formatspec)。  \n",
    "`str.format` 的声明符表示法和格式规范微语言类似，称作[格式字符串句法](https://docs.python.org/3/library/string.html#formatstrings)。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15 15.00 F\n"
     ]
    }
   ],
   "source": [
    "# format\n",
    "num = 15\n",
    "print(format(num, '2d'), format(num, '.2f'), format(num, 'X'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 对象散列化\n",
    "只有可散列的对象，才可以作为 `dict` 的 key，或者被加入 `set`.  \n",
    "要想创建可散列的类型，只需要实现 `__hash__` 和 `__eq__` 即可。  \n",
    "有一个要求：如果 `a == b`，那么 `hash(a) == hash(b)`.\n",
    "\n",
    "文中推荐的 hash 实现方法是使用位运算异或各个分量的散列值：\n",
    "```python\n",
    "class Vector2d:\n",
    "    # 其余部分省略\n",
    "    def __hash__(self):\n",
    "        return hash(self.x) ^ hash(self.y)\n",
    "```\n",
    "\n",
    "而最新的文章中，推荐把各个分量组成一个 `tuple`，然后对其进行散列：\n",
    "```python\n",
    "class Vector2d:\n",
    "    def __hash__(self):\n",
    "        return hash((self.x, self.y))\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python 的私有属性和“受保护的”属性\n",
    "Python 的“双下前导”变量：如果以 `__a` 的形式（双前导下划线，尾部最多有一个下划线）命名一个实例属性，Python 会在 `__dict__` 中将该属性进行“名称改写”为 `_Klass__a`，以防止外部对对象内部属性的直接访问。  \n",
    "这样可以避免意外访问，但**不能防止故意犯错**。\n",
    "\n",
    "有一种观点认为不应该使用“名称改写”特性，对于私有方法来说，可以使用前导单下划线 `_x` 来标注，而不应使用双下划线。\n",
    "\n",
    "此外：在 `from mymod import *` 中，任何使用下划线前缀（无论单双）的变量，都不会被导入。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'_Vector2d__x': 1, '_Vector2d__y': 2}\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "class Vector2d:\n",
    "    def __init__(self, x, y):\n",
    "        self.__x = x\n",
    "        self.__y = y\n",
    "    \n",
    "vector = Vector2d(1, 2)\n",
    "print(vector.__dict__)\n",
    "print(vector._Vector2d__x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 使用 __slot__ 类属性节省空间\n",
    "默认情况下，Python 在各个实例的 `__dict__` 字典中存储实例属性。但 Python 字典使用散列表实现，会消耗大量内存。  \n",
    "如果需要处理很多个属性**有限且相同**的实例，可以通过定义 `__slots__` 类属性，将实例用元组存储，以节省内存。\n",
    "\n",
    "```python\n",
    "class Vector2d:\n",
    "    __slots__ = ('__x', '__y')\n",
    "```\n",
    "\n",
    "`__slots__` 的目的是优化内存占用，而不是防止别人在实例中添加属性。_所以一般也没有什么使用的必要。_\n",
    "\n",
    "使用 `__slots__` 时需要注意的地方：\n",
    "* 子类不会继承父类的 `__slots_`\n",
    "* 实例只能拥有 `__slots__` 中所列出的属性\n",
    "* 如果不把 `\"__weakref__\"` 加入 `__slots__`，实例就不能作为弱引用的目标。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b'd\\x00\\x00\\x00\\x00\\x00\\x00\\xf0?\\x00\\x00\\x00\\x00\\x00\\x00\\x00@'\n",
      "(1, 2) (1.0, 2.0)\n"
     ]
    }
   ],
   "source": [
    "# 对象二进制化\n",
    "from array import array\n",
    "import math\n",
    "\n",
    "class Vector2d:\n",
    "    typecode = 'd'\n",
    "\n",
    "    def __init__(self, x, y):\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "    \n",
    "    def __str__(self):\n",
    "        return str(tuple(self))\n",
    "\n",
    "    def __iter__(self):\n",
    "        yield from (self.x, self.y)\n",
    "\n",
    "    def __bytes__(self):\n",
    "        return (bytes([ord(self.typecode)]) +\n",
    "                bytes(array(self.typecode, self)))\n",
    "    \n",
    "    def __eq__(self, other):\n",
    "        return tuple(self) == tuple(other)\n",
    "\n",
    "    @classmethod\n",
    "    def frombytes(cls, octets):\n",
    "        typecode = chr(octets[0])\n",
    "        memv = memoryview(octets[1:]).cast(typecode)\n",
    "        return cls(*memv)\n",
    "\n",
    "vector = Vector2d(1, 2)\n",
    "v_bytes = bytes(vector)\n",
    "vector2 = Vector2d.frombytes(v_bytes)\n",
    "print(v_bytes)\n",
    "print(vector, vector2)\n",
    "assert vector == vector2"
   ]
  }
 ],
 "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}