第08章：对象引用、可变性和垃圾回收.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 对象引用、可变性和垃圾回收\n",
    "\n",
    "~~这章的前言实在是太长了…~~\n",
    "\n",
    "Python 使用引用式变量：变量和变量名是两个不同的东西。\n",
    "\n",
    "在 Python 中，变量不是一个存储数据的盒子，而是一个针对盒子的标注。同时，一个盒子上可以有很多标注，也可以一个都没有。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4]\n",
      "ID 88908560\n",
      "Test <__main__.Test object at 0x054CA310> 88908560\n"
     ]
    }
   ],
   "source": [
    "a = [1, 2, 3]\n",
    "b = a\n",
    "a.append(4)\n",
    "print(b)\n",
    "\n",
    "# 对象会在赋值之前创建\n",
    "class Test:\n",
    "    def __init__(self):\n",
    "        print('ID', id(self))    # 在把 self 分配给 t 之前，self 就已经有了自己的 ID\n",
    "\n",
    "t = Test()\n",
    "print('Test', t, id(t))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 分清“==”和“is”\n",
    "# a is b 等同于 id(a) == id(b)\n",
    "a = {'a': 1}\n",
    "b = a\n",
    "assert a is b\n",
    "assert id(a) == id(b)\n",
    "\n",
    "c = {'a': 1}\n",
    "assert a == c\n",
    "assert not a is c\n",
    "assert id(a) != id(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在 CPython 中，id() 返回对象的内存地址，但在其他 Python 解释器中可能是别的值。关键是，ID 一定是唯一的数值标注，而且在对象的生命周期中绝不会变。  \n",
    "编程中，我们很少会使用 `id()` 函数，标识最常使用 `is` 运算符检查相同性，而不是直接比较 ID."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 与单例进行比较时，应该使用 is\n",
    "a = None\n",
    "assert a is None\n",
    "b = ...\n",
    "assert b is ...\n",
    "\n",
    "# a == b 是语法糖，等同于 a.__eq__(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, [30, 40, 50])\n"
     ]
    }
   ],
   "source": [
    "# 元组的相对不可变性\n",
    "t1 = (1, 2, [30, 40])\n",
    "t2 = (1, 2, [30, 40])\n",
    "assert t1 == t2\n",
    "\n",
    "id1 = id(t1[-1])\n",
    "t1[-1].append(50)\n",
    "print(t1)\n",
    "\n",
    "id2 = id(t1[-1])\n",
    "assert id1 == id2     # t1 的最后一个元素的标识没变，但是值变了\n",
    "assert t1 != t2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, [2, 3, 4, 5], (4, 5, 6)] [1, [2, 3, 4, 5], (4, 5, 6, 7, 8)]\n"
     ]
    }
   ],
   "source": [
    "# 浅复制\n",
    "# Python 对列表等进行复制时，只会复制容器，而不会复制容器内的内容\n",
    "a = [1, [2, 3], (4, 5, 6)]\n",
    "b = list(a)\n",
    "assert a == b\n",
    "assert a is not b     # b 是一个新对象\n",
    "assert a[1] is b[1]   # 但两个列表中的元素是同一个\n",
    "\n",
    "a[1] += [4, 5]        # a[1] = a[1] + [4, 5], list 就地执行操作后返回对象本身的引用\n",
    "b[2] += (7, 8)        # b[2] = b[2] + (7, 8), tuple 在执行操作后生成一个新对象并返回它的引用\n",
    "print(a, b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, [2, 3], (4, 5, 6)] [1, [2, 3, 4, 5], (4, 5, 6)]\n"
     ]
    }
   ],
   "source": [
    "# 深复制\n",
    "from copy import deepcopy\n",
    "a = [1, [2, 3], (4, 5, 6)]\n",
    "b = deepcopy(a)\n",
    "assert a == b\n",
    "assert a[1] is not b[1]      # 不单复制了容器，还复制了容器中的值\n",
    "\n",
    "b[1].extend([4, 5])\n",
    "print(a, b)\n",
    "assert a != b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Python 的传参方式：共享传参（call by sharing），只会传递引用\n",
    "def f(a, b):\n",
    "    a += b\n",
    "    return a\n",
    "\n",
    "a, b = [1, 2], [3, 4]\n",
    "c = f(a, b)\n",
    "assert a == c == [1, 2, 3, 4]\n",
    "assert a is c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2] [1, 2] [3]\n",
      "[3]\n"
     ]
    }
   ],
   "source": [
    "# 共享传参导致的问题\n",
    "# 可变参数作为函数默认值 & 跨作用域引用导致共享变量更改\n",
    "class Container:\n",
    "    def __init__(self, initial=[]):\n",
    "        self.values = initial\n",
    "    \n",
    "    def add(self, value):\n",
    "        self.values.append(value)\n",
    "\n",
    "a = Container()\n",
    "b = Container()\n",
    "l = []\n",
    "c = Container(l)\n",
    "a.add(1)\n",
    "b.add(2)\n",
    "c.add(3)\n",
    "print(a.values, b.values, c.values)\n",
    "assert a.values is b.values            # a.values 和 b.values 共享同一个变量（init 函数中的默认值）\n",
    "print(l)                               # l 和 c.values 共享同一个变量，c.values 更改后，l 也会更改\n",
    "assert c.values is l"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## del 和垃圾回收\n",
    "> 对象绝不会自行销毁；然而，无法得到对象时，可能会被当做垃圾回收。\n",
    "\n",
    "在 CPython 中，垃圾回收使用的主要算法时引用计数。当引用计数归零时，对象立即就被销毁。  \n",
    "销毁时，CPython 会先调用对象的 `__del__` 方法，然后释放分配给对象的内存。  \n",
    "CPython 2.0 增加了分代垃圾回收机制，用于检测循环引用中涉及的对象组。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "Bye\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "# 监测引用计数垃圾回收\n",
    "import weakref\n",
    "s1 = s2 = {1}\n",
    "ender = weakref.finalize(s1, lambda: print('Bye'))\n",
    "print(ender.alive)\n",
    "del s1                # 删除 s1 的引用\n",
    "print(ender.alive)    # 对象 {1} 的引用还在（s2）\n",
    "s2 = {2}\n",
    "print(ender.alive)    # 无法引用到 {1} 对象，于是它被垃圾回收"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 弱引用\n",
    "使用 `weakref.ref` 可以生成一个对象的引用，但不会增加它的引用计数\n",
    "\n",
    "`weakref.ref` 类实际上是低层接口，多数程序最好使用 `weakref` 集合和 `finalize`.\n",
    "\n",
    "`weakref` 提供的弱引用集合有 `WeakKeyDictionary`, `WeakValueDictionary`, `WeakSet`.  \n",
    "它们的用途可以从名字中得出。\n",
    "\n",
    "弱引用的局限：并不是所有对象都可以创建弱引用，比如 `list`, `dict`, `str` 实例。  \n",
    "但是，某些自定义类都可以创建弱引用（比如基于 `list` 生成的子类）。  \n",
    "`int` 和 `tuple` 实例及它们的子类实例都不能成为弱引用的目标。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<weakref at 0x00B10BD0; to 'set' at 0x00B35A08> {1}\n",
      "<weakref at 0x00B10BD0; dead> None\n"
     ]
    }
   ],
   "source": [
    "import weakref\n",
    "\n",
    "s1 = {1}\n",
    "ref = weakref.ref(s1)\n",
    "print(ref, ref())\n",
    "del s1\n",
    "print(ref, ref())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[('s1', {1}), ('s2', {2})]\n",
      "[('s1', {1})]\n"
     ]
    }
   ],
   "source": [
    "# WeakValueDictionary 实例\n",
    "from weakref import WeakValueDictionary\n",
    "\n",
    "weak_dict = WeakValueDictionary()\n",
    "s1, s2 = {1}, {2}\n",
    "weak_dict.update({\n",
    "    's1': s1,\n",
    "    's2': s2\n",
    "})\n",
    "print(list(weak_dict.items()))\n",
    "del s2\n",
    "print(list(weak_dict.items()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 一些杂事\n",
    "如果不可变集合（如 `tuple` 和 `frozenset`）中保存的是可变元素的引用，那么可变元素的值发生变化后，不可变集合也会发生改变。  \n",
    "这里指的是 `hash` 和 `==`的结果，即使集合中的对象更改，该对象在集合中存储的引用也是不会变的。\n",
    "\n",
    "`tuple()` 的参数如果是一个元组，则得到的是同一个对象。对元组使用 `[:]` 切片操作也不会生成新对象。  \n",
    "`str`, `bytes` 和 `frozenset` 实例也有这种行为。  \n",
    "`fs.copy()` 返回的是它本身（喵喵喵？）。\n",
    "\n",
    "字符串字面量可能会产生**驻留**现象：两个相等的字符串共享同一个字符串对象。  \n",
    "`int` 对象中，在 [-5, 256] 之间的整型实例也被提前创建，所有指向这些数字的引用均会共享对象。\n",
    "\n",
    "自定义对象中，如果没有实现 `__eq__` 方法，则进行 `==` 判断时会比较它们的 ID.  \n",
    "这种后备机制认为用户定义的类的各个实例是不同的。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = \"hahaha\"\n",
    "b = \"hahaha\"\n",
    "assert a is b\n",
    "\n",
    "a = 66\n",
    "b = 66\n",
    "assert a is b\n",
    "a = 257\n",
    "b = 257\n",
    "assert a is not b\n",
    "\n",
    "class T:\n",
    "    pass\n",
    "\n",
    "a = T()\n",
    "b = a\n",
    "c = T()\n",
    "assert a is b\n",
    "assert a is not c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 延伸阅读\n",
    "[Python Garbage Collector Implementations: CPython, PyPy and Gas](https://thp.io/2012/python-gc/python_gc_final_2012-01-22.pdf)"
   ]
  }
 ],
 "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.6.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}