chapter8.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 对象引用、可变性和垃圾回收"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 变量不是装值的盒子\n",
    "- 一般会说把对象分配给变量，而不是把变量分配给对象\n",
    "- 变量是到具体值的引用，创建对象之后，值已经存在，之后才把变量分配到对象，创建到值的引用\n",
    "- 对于赋值语句，对象先在右边创建或者获取，之后左边的变量才会绑定到对象上。变相就像是对象上贴的一个标注，一个对象可能会被贴多个标注（而不可能同时在多个盒子里）"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 在下面的例子中，a和b是别名，贴在同一个对象上；c和a,b的值一样，但贴在不同的对象上"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "import doctest"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = {'name': 'charles'}\n",
    "b = a\n",
    "a is b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c = {'name': 'charles'}\n",
    "c == a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a is c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2596893231000 2596893231000 2596893330240\n"
     ]
    }
   ],
   "source": [
    "print(id(a), id(b), id(c))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 元组的不可变性指的是元组数据结构的物理内容（即保存的引用）不可变，与引用的对象无关\n",
    "- 元组的值会随着引用的可变对象的变化而变\n",
    "- 不可变的是元素的标识(id)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 使用构造方法或者[:]进行列表复制是浅复制\n",
    "- 只复制外层容器\n",
    "- 副本中的元素是源容器中元素的引用\n",
    "- **如下，l1和l2指向不同的列表对象，但列表元素中的列表和元组指向相同的对象**\n",
    "- **同时对于列表和元组，即便它们作为列表元素，也保留了本身特性，即列表做浅复制而元组做深复制**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n",
      "True\n",
      "True\n",
      "l1: [3, [66, 44], (7, 8, 9), 100]\n",
      "l2: [3, [66, 44], (7, 8, 9)]\n",
      "True\n",
      "True\n",
      "False\n",
      "l1: [3, [66, 44, 33, 22], (7, 8, 9), 100]\n",
      "l2: [3, [66, 44, 33, 22], (7, 8, 9, 10, 11)]\n"
     ]
    }
   ],
   "source": [
    "l1 = [3, [66, 55, 44], (7, 8, 9)]\n",
    "l2 = list(l1)\n",
    "print(l1 is l2)\n",
    "print(l1[0] is l2[0])\n",
    "print(l1[1] is l2[1])\n",
    "print(l1[2] is l2[2])\n",
    "l1.append(100)\n",
    "l1[1].remove(55)\n",
    "print('l1:', l1)\n",
    "print('l2:', l2)\n",
    "l2[1] += [33, 22]\n",
    "l2[2] += (10, 11)\n",
    "print(l1[0] is l2[0])\n",
    "print(l1[1] is l2[1])\n",
    "print(l1[2] is l2[2])\n",
    "print('l1:', l1)\n",
    "print('l2:', l2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 使用deepcopy为任意对象做深复制\n",
    "- 即副本不共享内部对象的引用\n",
    "- deepcopy可以处理循环引用"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Bus:\n",
    "    \"\"\"\n",
    "        >>> import copy\n",
    "        >>> bus1 = Bus(['Alice', 'Bill', 'Claire', 'David'])\n",
    "        >>> bus2 = copy.copy(bus1)\n",
    "        >>> bus3 = copy.deepcopy(bus1)\n",
    "        >>> bus1.drop('Bill')\n",
    "        >>> bus2.passengers\n",
    "        ['Alice', 'Claire', 'David']\n",
    "        >>> bus3.passengers\n",
    "        ['Alice', 'Bill', 'Claire', 'David']\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, passengers=None):\n",
    "        if passengers is None:\n",
    "            self.passengers = []\n",
    "        else:\n",
    "            self.passengers = list(passengers)\n",
    "\n",
    "    def pick(self, name):\n",
    "        self.passengers.append(name)\n",
    "\n",
    "    def drop(self, name):\n",
    "        self.passengers.remove(name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Trying:\n",
      "    import copy\n",
      "Expecting nothing\n",
      "ok\n",
      "Trying:\n",
      "    bus1 = Bus(['Alice', 'Bill', 'Claire', 'David'])\n",
      "Expecting nothing\n",
      "ok\n",
      "Trying:\n",
      "    bus2 = copy.copy(bus1)\n",
      "Expecting nothing\n",
      "ok\n",
      "Trying:\n",
      "    bus3 = copy.deepcopy(bus1)\n",
      "Expecting nothing\n",
      "ok\n",
      "Trying:\n",
      "    bus1.drop('Bill')\n",
      "Expecting nothing\n",
      "ok\n",
      "Trying:\n",
      "    bus2.passengers\n",
      "Expecting:\n",
      "    ['Alice', 'Claire', 'David']\n",
      "ok\n",
      "Trying:\n",
      "    bus3.passengers\n",
      "Expecting:\n",
      "    ['Alice', 'Bill', 'Claire', 'David']\n",
      "ok\n",
      "5 items had no tests:\n",
      "    __main__\n",
      "    __main__.Bus.__init__\n",
      "    __main__.Bus.drop\n",
      "    __main__.Bus.pick\n",
      "    __main__.yapf_reformat\n",
      "1 items passed all tests:\n",
      "   7 tests in __main__.Bus\n",
      "7 tests in 6 items.\n",
      "7 passed and 0 failed.\n",
      "Test passed.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "TestResults(failed=0, attempted=7)"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "doctest.testmod(verbose=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, [[...], 3]]\n",
      "[[1, 2, [...]], 3]\n",
      "[[1, 2, [...]], 3]\n",
      "[[1, 2, [...]], 3]\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "import copy\n",
    "a = [1, 2]\n",
    "b = [a, 3]\n",
    "a.append(b)\n",
    "print(a)\n",
    "print(a[2])\n",
    "print(a[2][0][2][0][2][0][2][0][2][0][2][0][2])\n",
    "b = copy.deepcopy(a)\n",
    "print(b[2][0][2][0][2][0][2][0][2][0][2][0][2])\n",
    "print(b is a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python只支持共享传参\n",
    "- 函数的各个形式参数获得实参中各个引用的副本\n",
    "- 函数内部的形参是实参的别名\n",
    "- 因此函数可能会修改接收到的任何可变对象"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "1 2\n"
     ]
    }
   ],
   "source": [
    "def f(a, b):\n",
    "    a += b\n",
    "    return a\n",
    "\n",
    "\n",
    "x = 1\n",
    "y = 2\n",
    "print(f(x, y))\n",
    "print(x, y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4]\n",
      "[1, 2, 3, 4] [3, 4]\n"
     ]
    }
   ],
   "source": [
    "a = [1, 2]\n",
    "b = [3, 4]\n",
    "print(f(a, b))\n",
    "print(a, b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 可选参数可以有默认值，但是默认值应该避免使用可变的对象，否则在初始化一个新对象时，其参数可能指向一个之前的对象的参数（默认可变对象）\n",
    "- 比如下面这个幽灵车的例子，bus3初始化后，应该没有任何乘客，但是出现了bus2中的'Carrie'，之后bus3中上车的乘客也出现在了bus2中。这是因为两个bus使用默认值初始化，这时默认值是一个可变列表，因此它们指向同一个列表\n",
    "- 因此一般用None作为默认值，否则则需要将参数passengers的副本传给self.passengers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "class HauntedBus:\n",
    "    def __init__(self, passengers=[]):\n",
    "        self.passengers = passengers\n",
    "\n",
    "    def pick(self, name):\n",
    "        self.passengers.append(name)\n",
    "\n",
    "    def drop(self, name):\n",
    "        self.passengers.remove(name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Alice', 'Bill']"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bus1 = HauntedBus(['Alice', 'Bill'])\n",
    "bus1.passengers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Bill', 'Charlie']"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bus1.pick('Charlie')\n",
    "bus1.drop('Alice')\n",
    "bus1.passengers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Carrie']"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bus2 = HauntedBus()\n",
    "bus2.pick('Carrie')\n",
    "bus2.passengers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Carrie']"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bus3 = HauntedBus()\n",
    "bus3.passengers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Carrie', 'Dave']"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bus3.pick('Dave')\n",
    "bus2.passengers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bus2.passengers is bus3.passengers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Bill', 'Charlie']"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bus1.passengers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 因此当不希望函数修改传入的参数时，应该防御可变参数\n",
    "- 即做一次浅复制"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "class TwilightBus:\n",
    "    def __init__(self, passengers=None):\n",
    "        if passengers is None:\n",
    "            self.passengers = []\n",
    "        else:\n",
    "            self.passengers = list(passengers)\n",
    "\n",
    "    def pick(self, name):\n",
    "        self.passengers.append(name)\n",
    "\n",
    "    def drop(self, name):\n",
    "        self.passengers.remove(name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 对象绝不会自行销毁，然而，无法得到对象时，可能会被当作垃圾回收\n",
    "- del删除名称，而不是对象\n",
    "- 当del删除了对象的最后一个引用时，或者两个对象只剩下相互引用时，对象会被销毁"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 弱引用\n",
    "- 场景：需要引用对象，但是不让对象存在的时间超过所需时间\n",
    "- 弱引用不增加对象的引用数量，不妨碍对象被回收，弱引用的目标对象成为所指对象(referent)\n",
    "- int和tuple实例不能作为弱引用目标\n",
    "- set可以\n",
    "- list不可以，但是list的子类可以"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<weakref at 0x0000025CA369CEA8; to 'set' at 0x0000025CA358B588>\n"
     ]
    }
   ],
   "source": [
    "import weakref\n",
    "a_set = {0, 1}\n",
    "wref = weakref.ref(a_set)\n",
    "print(wref)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0, 1}"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "wref()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [],
   "source": [
    "a_set = {2, 3, 4}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0, 1}"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "wref()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "print(wref() is None)\n",
    "print(wref() is None)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## WeakValueDictionary\n",
    "- 值是对象的弱引用\n",
    "- 当被引用的对象被回收后，对应的键会自动删除。该结构多用于缓存\n",
    "- 对应的还有WeakKeyDictionary、WeakSet"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Cheese:\n",
    "    def __init__(self, kind):\n",
    "        self.kind = kind\n",
    "\n",
    "    def __repr__(self):\n",
    "        return 'Cheese(%r)' % self.kind"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [],
   "source": [
    "import weakref\n",
    "stock = weakref.WeakValueDictionary()\n",
    "catalog = [\n",
    "    Cheese('Red Leicester'),\n",
    "    Cheese('Tilsit'),\n",
    "    Cheese('Brie'),\n",
    "    Cheese('Parmesan')\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [],
   "source": [
    "for cheese in catalog:\n",
    "    stock[cheese.kind] = cheese"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Brie', 'Parmesan', 'Red Leicester', 'Tilsit']"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorted(stock.keys())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Parmesan']"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "del catalog\n",
    "sorted(stock.keys())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "del cheese\n",
    "sorted(stock.keys())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 在删除catalog后，只留下了Parmesan，为什么？\n",
    "- **因为还有一个指向Parmesan的引用，即cheese，Parmesan是cheese最后一次循环指向的对象**"
   ]
  }
 ],
 "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
}