Tips/2016-05-02-Class-and-Metaclass-ii.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Python 类与元类的深度挖掘 II\n",
    "\n",
    "上一篇解决了通过调用**类对象**生成**实例对象**过程中可能遇到的命名空间相关的一些问题，这次我们向上回溯一层，看看类对象本身是如何产生的。\n",
    "\n",
    "我们知道 `type()` 方法可以查看一个对象的类型，或者说判断这个对象是由那个类产生的："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n",
      "<class 'str'>\n"
     ]
    }
   ],
   "source": [
    "print(type(12))\n",
    "print(type('python'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'type'>\n"
     ]
    }
   ],
   "source": [
    "class A:\n",
    "    pass\n",
    "print(type(A))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "通过这段代码可以看出，类对象 `A` 是由`type()` 产生的，也就是说 `type` 也可以用来产生新的对象，而且产生的是**类对象**，因此它是所有类对象的类："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "type(object_or_name, bases, dict)\n",
      "type(object) -> the object's type\n",
      "type(name, bases, dict) -> a new type\n"
     ]
    }
   ],
   "source": [
    "print(type.__doc__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`class` 定义类的语法实际上转化为 `type(name, bases, dict)`，其中 `name` 参数为类的名字，`bases` 为继承父类的元组，`dict` 为类的属性和方法："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "class A:\n",
    "    pass\n",
    "# 实际上等于\n",
    "B = type('A', (), {})\n",
    "\n",
    "print(A.__name__ == B.__name__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "理论上说这就是元类的意义，但从实际的角度出发显然使用 `class` 语法更方便、合理，而元类的实际意义则是通过继承 `type` 类来构造一个新的元类，并进行特定的操作以产生具有特定行为的类对象。这样看来它的本质与普通的类对象没有差异，只不过继承的是 `type` 类。\n",
    "\n",
    "在生成实例时是通过调用 `__init__` 方法进行初始化的，而实际上在此之前会先调用 `__new__` 方法用于**创建**实例，再通过 `__init__` 初始化，就好像 `__new__` 负责声明变量，而 `__init__` 负责对声明的变量进行初始化一样。这里有一个规则是 `__new__(cls,)` 的返回值必须是 `cls` 参数的实例，否则 `__init__` 将不会触发，例如在 `enum.Enum` 的定义中，由于枚举类型是单例模式，因此在定义 `__new__` 的时候没有返回其实例，也就不会进行初始化："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class '__main__.Enum'> 1\n"
     ]
    }
   ],
   "source": [
    "class Enum:\n",
    "    def __new__(cls, value):\n",
    "        print(cls, value)\n",
    "        return value\n",
    "    def __init__(self):\n",
    "        print(\"Will not be called!\")\n",
    "e = Enum(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "通常情况下自己定义 `__new__` 需要通过调用父类的 `__new__` 方法创建一个 `cls` 的实例，同样在定义元类的时候则是调用上面提到的 `type` 的用法（因为元类继承自 `type`）："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class MetaEnum(type):\n",
    "    def __new__(metaclass, name, base, attrs):\n",
    "        print(\"Metaclass: {}\\nName: {}\\nParents: {}\\nAttributes: {}\".format(metaclass, name, base, attrs))\n",
    "        return super().__new__(metaclass, name, base, attrs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Metaclass: <class '__main__.MetaEnum'>\n",
      "Name: Enum\n",
      "Parents: ()\n",
      "Attributes: {'__qualname__': 'Enum', '__module__': '__main__', 'test': 0}\n"
     ]
    }
   ],
   "source": [
    "class Enum(metaclass=MetaEnum):\n",
    "    # Python 2.7 中定义元类的方法是使用 __metaclass__ 变量\n",
    "    # [PEP 3115](https://www.python.org/dev/peps/pep-3115/)\n",
    "    # 将 Python 3.0 以后语法改为 class Cls(metaclass=Meta)\n",
    "    test = 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "此时我们再来看 `Enum` 的类，已经不再是 `type` 而是其元类 `MetaEnum`："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "__main__.MetaEnum"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(Enum)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "除了 `__new__` 方法之外，[PEP 3115](https://www.python.org/dev/peps/pep-3115/) 还定义了 `__prepare__` 属性，用于设定初始化的命名空间（即 `type` 的第 3 个参数），还是以 `enum.Enum` 为例，我们需要限制枚举类型中属性名称不得重复使用，则可以通过元类限制类的行为："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "TypeError catched\n"
     ]
    }
   ],
   "source": [
    "# 定义新的字典类，在赋值新的 dict[k] = v 时\n",
    "# 检查 k 是否重复\n",
    "class _EnumDict(dict):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        self.members = []\n",
    "    def __setitem__(self, k, v):\n",
    "        if k in self.members:\n",
    "            raise TypeError(\"Attempted to reuse key: '{}'\".format(k))\n",
    "        else:\n",
    "            self.members.append(k)\n",
    "            super().__setitem__(k, v)\n",
    "            \n",
    "class MetaEnum(type):\n",
    "    @classmethod\n",
    "    def __prepare__(metaclass, cls, bases):\n",
    "        return _EnumDict()\n",
    "    def __new__(metaclass, name, base, attrs):\n",
    "        return super().__new__(metaclass, name, base, attrs)\n",
    "class Enum(metaclass=MetaEnum):\n",
    "    pass\n",
    "\n",
    "class Color(Enum):\n",
    "    try:\n",
    "        red = 1\n",
    "        red = 2\n",
    "    except TypeError:# 这里没有使用 as err: 的原因是？\n",
    "        print(\"TypeError catched\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python 中一切皆为对象，所有的对象都是某一类的实例，或是某一元类的实例，`type` 是自己的元类也是自己的实例：\n",
    "\n",
    "![metaclass](http://qncdn.rainy.im/pytips/metaclass2.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 总结\n",
    "\n",
    "元类在 Python 中属于比较深层的黑魔法，在一般的日常应用中可能并不常用，但理解其背后的原理对于理解 Python 面向对象编程以及一切皆为对象的理念很有帮助；如果你需要对类进行深度改造，至少要知道从何入手。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 参考\n",
    "\n",
    "1. [What is a metaclass in Python](http://stackoverflow.com/questions/100003/what-is-a-metaclass-in-python)"
   ]
  }
 ],
 "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.5.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}