theory/python/eyes/9.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 第九章 有益的探索"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "尝试着潜入水中，往冰山的深处扎一个小小的猛子"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 9.1 数据类型的底层实现"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 9.1.1 从奇怪的列表说起"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**1、错综复杂的复制**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "list_1 = [1, [22, 33, 44], (5, 6, 7), {\"name\": \"Sarah\"}]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 浅拷贝"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# list_3 = list_1          # 错误！！！\n",
    "list_2 = list_1.copy()     # 或者list_1[:] \\ list(list_1) 均可实习浅拷贝"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 对浅拷贝前后两列表分别进行操作"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "list_1:   [1, [22, 33, 44, 55], (5, 6, 7), {'name': 'Sarah'}]\n",
      "list_2:   [1, [22, 33, 44, 55], (5, 6, 7), {'name': 'Sarah'}]\n"
     ]
    }
   ],
   "source": [
    "list_2[1].append(55)\n",
    "\n",
    "print(\"list_1:  \", list_1)\n",
    "print(\"list_2:  \", list_2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**2、列表的底层实现**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**引用数组的概念**  \n",
    "  \n",
    "列表内的元素可以分散的存储在内存中  \n",
    "  \n",
    "列表存储的，实际上是这些**元素的地址！！！**——地址的存储在内存中是连续的"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "list_1 = [1, [22, 33, 44], (5, 6, 7), {\"name\": \"Sarah\"}]\n",
    "list_2 = list(list_1)   # 浅拷贝   与list_1.copy()功能一样"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "（1）新增元素"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "list_1:   [1, [22, 33, 44], (5, 6, 7), {'name': 'Sarah'}, 100]\n",
      "list_2:   [1, [22, 33, 44], (5, 6, 7), {'name': 'Sarah'}, 'n']\n"
     ]
    }
   ],
   "source": [
    "list_1.append(100)\n",
    "list_2.append(\"n\")\n",
    "\n",
    "print(\"list_1:  \", list_1)\n",
    "print(\"list_2:  \", list_2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "（2）修改元素"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "list_1:   [10, [22, 33, 44], (5, 6, 7), {'name': 'Sarah'}, 100]\n",
      "list_2:   [20, [22, 33, 44], (5, 6, 7), {'name': 'Sarah'}, 'n']\n"
     ]
    }
   ],
   "source": [
    "list_1[0] = 10\n",
    "list_2[0] = 20\n",
    "\n",
    "print(\"list_1:  \", list_1)\n",
    "print(\"list_2:  \", list_2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "（3）对列表型元素进行操作"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "list_1:   [10, [22, 33, 55, 66], (5, 6, 7), {'name': 'Sarah'}, 100]\n",
      "list_2:   [20, [22, 33, 55, 66], (5, 6, 7), {'name': 'Sarah'}, 'n']\n"
     ]
    }
   ],
   "source": [
    "list_1[1].remove(44)\n",
    "list_2[1] += [55, 66]\n",
    "\n",
    "print(\"list_1:  \", list_1)\n",
    "print(\"list_2:  \", list_2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "（4）对元组型元素进行操作"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "list_1:   [10, [22, 33, 55, 66], (5, 6, 7), {'name': 'Sarah'}, 100]\n",
      "list_2:   [20, [22, 33, 55, 66], (5, 6, 7, 8, 9), {'name': 'Sarah'}, 'n']\n"
     ]
    }
   ],
   "source": [
    "list_2[2] += (8,9)\n",
    "\n",
    "print(\"list_1:  \", list_1)\n",
    "print(\"list_2:  \", list_2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "元组是不可变的！！！"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "（5）对字典型元素进行操作"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "list_1:   [10, [22, 33, 55, 66], (5, 6, 7), {'name': 'Sarah', 'age': 18}, 100]\n",
      "list_2:   [20, [22, 33, 55, 66], (5, 6, 7, 8, 9), {'name': 'Sarah', 'age': 18}, 'n']\n"
     ]
    }
   ],
   "source": [
    "list_1[-2][\"age\"] = 18\n",
    "\n",
    "print(\"list_1:  \", list_1)\n",
    "print(\"list_2:  \", list_2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**3、引入深拷贝**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**浅拷贝之后**  \n",
    "  \n",
    "* 针对不可变元素（数字、字符串、元组）的操作，都各自生效了  \n",
    "  \n",
    "* 针对不可变元素（列表、集合）的操作，发生了一些混淆"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**引入深拷贝**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 深拷贝将所有层级的相关元素全部复制，完全分开，泾渭分明，避免了上述问题"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "list_1:   [1, [22, 33, 44], (5, 6, 7), {'name': 'Sarah', 'age': 18}]\n",
      "list_2:   [1, [22, 33, 44, 55], (5, 6, 7), {'name': 'Sarah'}]\n"
     ]
    }
   ],
   "source": [
    "import copy\n",
    "\n",
    "list_1 = [1, [22, 33, 44], (5, 6, 7), {\"name\": \"Sarah\"}]\n",
    "list_2 = copy.deepcopy(list_1)\n",
    "list_1[-1][\"age\"] = 18\n",
    "list_2[1].append(55)\n",
    "\n",
    "print(\"list_1:  \", list_1)\n",
    "print(\"list_2:  \", list_2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 9.1.2 神秘的字典"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**1、快速的查找**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "查找1000个元素，在ls_1列表中的有500个，共用时6.19秒\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "\n",
    "ls_1 = list(range(1000000))\n",
    "ls_2 = list(range(500))+[-10]*500\n",
    "\n",
    "start = time.time()\n",
    "count = 0\n",
    "for n in ls_2:\n",
    "    if n in ls_1:\n",
    "        count += 1\n",
    "end = time.time()\n",
    "print(\"查找{}个元素，在ls_1列表中的有{}个，共用时{}秒\".format(len(ls_2), count,round((end-start),2)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "查找1000个元素，在ls_1列表中的有500个，共用时0秒\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "\n",
    "d = {i:i for i in range(100000)}\n",
    "ls_2 = list(range(500))+[-10]*500\n",
    "\n",
    "start = time.time()\n",
    "count = 0\n",
    "for n in ls_2:\n",
    "    try:\n",
    "        d[n]\n",
    "    except:\n",
    "        pass\n",
    "    else:\n",
    "        count += 1\n",
    "end = time.time()\n",
    "print(\"查找{}个元素，在ls_1列表中的有{}个，共用时{}秒\".format(len(ls_2), count,round(end-start)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**2、字典的底层实现**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "通过稀疏数组来实现值的存储与访问"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**字典的创建过程**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 第一步：创建一个散列表（稀疏数组 N >> n）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [],
   "source": [
    "d = {}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 第一步：通过hash()计算键的散列值"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-4771046564460599764\n",
      "1024\n",
      "3713081631934410656\n"
     ]
    }
   ],
   "source": [
    "print(hash(\"python\"))\n",
    "print(hash(1024))\n",
    "print(hash((1,2)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d[\"age\"] = 18    # 增加键值对的操作，首先会计算键的散列值hash(\"age\")\n",
    "print(hash(\"age\")) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 第二步：根据计算的散列值确定其在散列表中的位置"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "极个别时候，散列值会发生冲突，则内部有相应的解决冲突的办法"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 第三步：在该位置上存入值"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(2, 2):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**键值对的访问过程**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d[\"age\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 第一步：计算要访问的键的散列值"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 第二步：根据计算的散列值，通过一定的规则，确定其在散列表中的位置"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 第三步：读取该位置上存储的值\n",
    "  \n",
    "       如果存在，则返回该值  \n",
    "       如果不存在，则报错KeyError"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**3、小结**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**（1）字典数据类型，通过空间换时间，实现了快速的数据查找**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 也就注定了字典的空间利用效率低下"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**（2）因为散列值对应位置的顺序与键在字典中显示的顺序可能不同，因此表现出来字典是无序的**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 回顾一下 N >> n  \n",
    "如果N = n，会产生很多位置冲突"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 思考一下开头的小例子，为什么字典实现了比列表更快速的查找"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 9.1.3 紧凑的字符串"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**通过紧凑数组实现字符串的存储**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 数据在内存中是连续存放的，效率更高，节省空间"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 思考一下，同为序列类型，为什么列表采用引用数组，而字符串采用紧凑数组"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 9.1.4 是否可变"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**1、不可变类型：数字、字符串、元组**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**在生命周期中保持内容不变**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 换句话说，改变了就不是它自己了（id变了）"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 不可变对象的 += 操作 实际上创建了一个新的对象"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x id: 140718440616768\n",
      "y id: 2040939892664\n"
     ]
    }
   ],
   "source": [
    "x = 1\n",
    "y = \"Python\"\n",
    "\n",
    "print(\"x id:\", id(x))\n",
    "print(\"y id:\", id(y))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x id: 140718440616832\n",
      "y id: 2040992707056\n"
     ]
    }
   ],
   "source": [
    "x += 2\n",
    "y += \"3.7\"\n",
    "\n",
    "print(\"x id:\", id(x))\n",
    "print(\"y id:\", id(y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**元组并不是总是不可变的**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, [2, 3])\n"
     ]
    }
   ],
   "source": [
    "t = (1,[2])\n",
    "t[1].append(3)\n",
    "\n",
    "print(t)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**2、可变类型：列表、字典、集合**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* id 保持不变，但是里面的内容可以变"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 可变对象的 += 操作 实际在原对象的基础上就地修改"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ls id: 2040991750856\n",
      "d id: 2040992761608\n"
     ]
    }
   ],
   "source": [
    "ls = [1, 2, 3]\n",
    "d = {\"Name\": \"Sarah\", \"Age\": 18}\n",
    "\n",
    "print(\"ls id:\", id(ls))\n",
    "print(\"d id:\", id(d))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ls id: 2040991750856\n",
      "d id: 2040992761608\n"
     ]
    }
   ],
   "source": [
    "ls += [4, 5]\n",
    "d_2 = {\"Sex\": \"female\"}\n",
    "d.update(d_2)            # 把d_2 中的元素更新到d中\n",
    "\n",
    "print(\"ls id:\", id(ls))\n",
    "print(\"d id:\", id(d))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 9.1.5 列表操作的几个小例子"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**【例1】 删除列表内的特定元素**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 方法1 存在运算删除法"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "缺点：每次存在运算，都要从头对列表进行遍历、查找、效率低"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['2', '2', '4']\n"
     ]
    }
   ],
   "source": [
    "alist = [\"d\", \"d\", \"d\", \"2\", \"2\", \"d\" ,\"d\", \"4\"]\n",
    "s = \"d\"\n",
    "while True:\n",
    "    if s in alist:\n",
    "        alist.remove(s)\n",
    "    else:\n",
    "        break\n",
    "print(alist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 方法2 一次性遍历元素执行删除"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['2', '2', 'd', 'd', '4']\n"
     ]
    }
   ],
   "source": [
    "alist = [\"d\", \"d\", \"d\", \"2\", \"2\", \"d\" ,\"d\", \"4\"]\n",
    "for s in alist:\n",
    "    if s == \"d\":\n",
    "        alist.remove(s)      # remove（s） 删除列表中第一次出现的该元素\n",
    "print(alist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "解决方法：使用负向索引"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['2', '2', '4']\n"
     ]
    }
   ],
   "source": [
    "alist = [\"d\", \"d\", \"d\", \"2\", \"2\", \"d\" ,\"d\", \"4\"]\n",
    "for i in range(-len(alist), 0):\n",
    "    if alist[i] == \"d\":\n",
    "        alist.remove(alist[i])      # remove（s） 删除列表中第一次出现的该元素\n",
    "print(alist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**【例2】 多维列表的创建**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n",
       " [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n",
       " [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n",
       " [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n",
       " [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ls = [[0]*10]*5\n",
    "ls"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n",
       " [1, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n",
       " [1, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n",
       " [1, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n",
       " [1, 0, 0, 0, 0, 0, 0, 0, 0, 0]]"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ls[0][0] = 1\n",
    "ls"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 9.2 更加简洁的语法"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 9.2.1 解析语法"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n",
       " [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n",
       " [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n",
       " [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n",
       " [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ls = [[0]*10 for i in range(5)]\n",
    "ls"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n",
       " [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n",
       " [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n",
       " [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n",
       " [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ls[0][0] = 1\n",
    "ls"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**1、解析语法的基本结构——以列表解析为例（也称为列表推导）**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[expression **for value in iterable** if conditihon]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 三要素：表达式、可迭代对象、if条件（可选）"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**执行过程**\n",
    "  \n",
    "（1）从可迭代对象中拿出一个元素\n",
    "  \n",
    "（2）通过if条件（如果有的话），对元素进行筛选\n",
    "\n",
    "     若通过筛选：则把元素传递给表达式  \n",
    "       \n",
    "     若未通过：  则进入（1）步骤，进入下一次迭代\n",
    "  \n",
    "（3）将传递给表达式的元素，代入表达式进行处理，产生一个结果\n",
    "\n",
    "（4）将（3）步产生的结果作为列表的一个元素进行存储\n",
    "\n",
    "（5）重复（1）~（4）步，直至迭代对象迭代结束，返回新创建的列表"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 等价于如下代码\n",
    "result = []\n",
    "for value in iterale:\n",
    "    if condition:\n",
    "        result.append(expression)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "【例】求20以内奇数的平方"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 9, 25, 49, 81, 121, 169, 225, 289, 361]\n"
     ]
    }
   ],
   "source": [
    "squares = []\n",
    "for i in range(1,21):\n",
    "    if i%2 == 1:\n",
    "        squares.append(i**2)\n",
    "print(squares)   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 9, 25, 49, 81, 121, 169, 225, 289, 361]\n"
     ]
    }
   ],
   "source": [
    "squares = [i**2 for i in range(1,21) if i%2 == 1]\n",
    "print(squares) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**支持多变量**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 4, 9]"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = [1, 2, 3]\n",
    "y = [1, 2, 3]\n",
    "\n",
    "results = [i*j for i,j in zip(x, y)]\n",
    "results"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**支持循环嵌套**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['black S', 'black M', 'black L', 'white S', 'white M', 'white L']"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "colors = [\"black\", \"white\"]\n",
    "sizes = [\"S\", \"M\", \"L\"]\n",
    "tshirts = [\"{} {}\".format(color, size) for color in colors for size in sizes]\n",
    "tshirts"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**2、其他解析语法的例子**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 解析语法构造字典（字典推导）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 :   0\n",
      "1 :   1\n",
      "2 :   4\n",
      "3 :   9\n",
      "4 :   16\n",
      "5 :   25\n",
      "6 :   36\n",
      "7 :   49\n",
      "8 :   64\n",
      "9 :   81\n"
     ]
    }
   ],
   "source": [
    "squares = {i: i**2 for i in range(10)}\n",
    "for k, v in squares.items():\n",
    "    print(k, \":  \", v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 解析语法构造集合（集合推导）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0, 1, 4, 9, 16, 25, 36, 49, 64, 81}"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "squares = {i**2 for i in range(10)}\n",
    "squares"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 生成器表达式"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<generator object <genexpr> at 0x000001DB37A58390>"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "squares = (i**2 for i in range(10))\n",
    "squares"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "black S\n",
      "black M\n",
      "black L\n",
      "white S\n",
      "white M\n",
      "white L\n"
     ]
    }
   ],
   "source": [
    "colors = [\"black\", \"white\"]\n",
    "sizes = [\"S\", \"M\", \"L\"]\n",
    "tshirts = (\"{} {}\".format(color, size) for color in colors for size in sizes)\n",
    "for tshirt in tshirts:\n",
    "    print(tshirt)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 9.2.2 条件表达式"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "expr1 if condition else expr2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "【例】将变量n的绝对值赋值给变量x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n = -10\n",
    "if n >= 0:\n",
    "    x = n\n",
    "else:\n",
    "    x = -n\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n = -10\n",
    "x = n if n>= 0 else -n\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**条件表达式和解析语法简单实用、运行速度相对更快一些，相信大家会慢慢的爱上它们**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 9.3 三大神器"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 9.3.1 生成器"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "ls = [i**2 for i in range(1, 1000001)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in ls:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "缺点：占用大量内存"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**生成器**  \n",
    "  \n",
    "  （1）采用惰性计算的方式   \n",
    "     \n",
    "  （2）无需一次性存储海量数据  \n",
    "  \n",
    "  （3）一边执行一边计算，只计算每次需要的值\n",
    "  \n",
    "  （4）实际上一直在执行next()操作，直到无值可取\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**1、生成器表达式**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 海量数据，不需存储"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "squares = (i**2 for i in range(1000000))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in squares:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 求0~100的和"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "无需显示存储全部数据，节省内存"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5050"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum((i for i in range(101)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**2、生成器函数——yield**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 生产斐波那契数列"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "数列前两个元素为1,1 之后的元素为其前两个元素之和"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 1, 2, 3, 5, 8, 13, 21, 34, 55]"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def fib(max):\n",
    "    ls = []\n",
    "    n, a, b = 0, 1, 1\n",
    "    while n < max:\n",
    "        ls.append(a)\n",
    "        a, b = b, a + b\n",
    "        n = n + 1\n",
    "    return ls\n",
    "\n",
    "\n",
    "fib(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "中间尝试"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "1\n",
      "2\n",
      "3\n",
      "5\n",
      "8\n",
      "13\n",
      "21\n",
      "34\n",
      "55\n"
     ]
    }
   ],
   "source": [
    "def fib(max):\n",
    "    n, a, b = 0, 1, 1\n",
    "    while n < max:\n",
    "        print(a)\n",
    "        a, b = b, a + b\n",
    "        n = n + 1\n",
    "\n",
    "\n",
    "fib(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "构造生成器函数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在每次调用next()的时候执行，遇到yield语句返回，再次执行时从上次返回的yield语句处继续执行"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<generator object fib at 0x000001BE11B19048>"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def fib(max):\n",
    "    n, a, b = 0, 1, 1\n",
    "    while n < max:\n",
    "        yield a\n",
    "        a, b = b, a + b\n",
    "        n = n + 1\n",
    "        \n",
    "\n",
    "fib(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "1\n",
      "2\n",
      "3\n",
      "5\n",
      "8\n",
      "13\n",
      "21\n",
      "34\n",
      "55\n"
     ]
    }
   ],
   "source": [
    "for i in fib(10):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 9.3.2 迭代器"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**1、可迭代对象**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "可直接作用于for循环的对象统称为可迭代对象：Iterable"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "scrolled": true
   },
   "source": [
    "**（1）列表、元组、字符串、字典、集合、文件**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "可以使用isinstance()判断一个对象是否是Iterable对象"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from collections import Iterable\n",
    "\n",
    "isinstance([1, 2, 3], Iterable)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "isinstance({\"name\": \"Sarah\"}, Iterable)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "isinstance('Python', Iterable)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**（2）生成器**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "squares = (i**2 for i in range(5))\n",
    "isinstance(squares, Iterable)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "生成器不但可以用于for循环，还可以被next()函数调用"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "4\n",
      "9\n",
      "16\n"
     ]
    }
   ],
   "source": [
    "print(next(squares))\n",
    "print(next(squares))\n",
    "print(next(squares))\n",
    "print(next(squares))\n",
    "print(next(squares))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "直到没有数据可取，抛出StopIteration"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "ename": "StopIteration",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mStopIteration\u001b[0m                             Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-66-f5163ac9e49b>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnext\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0msquares\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mStopIteration\u001b[0m: "
     ]
    }
   ],
   "source": [
    "print(next(squares))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**可以被next()函数调用并不断返回下一个值，直至没有数据可取的对象称为迭代器：Iterator**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**2、迭代器**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "可以使用isinstance()判断一个对象是否是Iterator对象"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**（1） 生成器都是迭代器**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from collections import Iterator\n",
    "\n",
    "squares = (i**2 for i in range(5))\n",
    "isinstance(squares, Iterator)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**（2） 列表、元组、字符串、字典、集合不是迭代器**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "isinstance([1, 2, 3], Iterator)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "可以通过iter(Iterable)创建迭代器"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "isinstance(iter([1, 2, 3]), Iterator)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "for item in Iterable 等价于：\n",
    "  \n",
    "    先通过iter()函数获取可迭代对象Iterable的迭代器\n",
    "  \n",
    "    然后对获取到的迭代器不断调用next()方法来获取下一个值并将其赋值给item\n",
    "   \n",
    "    当遇到StopIteration的异常后循环结束"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**（3）zip enumerate 等itertools里的函数是迭代器**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<zip at 0x1be11b13c48>"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = [1, 2]\n",
    "y = [\"a\", \"b\"]\n",
    "zip(x, y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 'a')\n",
      "(2, 'b')\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "for i in zip(x, y):\n",
    "    print(i)\n",
    "    \n",
    "isinstance(zip(x, y), Iterator)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<enumerate at 0x1be11b39990>"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numbers = [1, 2, 3, 4, 5]\n",
    "enumerate(numbers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(0, 1)\n",
      "(1, 2)\n",
      "(2, 3)\n",
      "(3, 4)\n",
      "(4, 5)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "for i in enumerate(numbers):\n",
    "    print(i)\n",
    "    \n",
    "isinstance(enumerate(numbers), Iterator)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**(4) 文件是迭代器**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "with open(\"测试文件.txt\", \"r\", encoding = \"utf-8\") as f:\n",
    "    print(isinstance(f, Iterator))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**（5）迭代器是可耗尽的**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "4\n",
      "9\n",
      "16\n"
     ]
    }
   ],
   "source": [
    "squares = (i**2 for i in range(5))\n",
    "for square in squares:\n",
    "    print(square)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [],
   "source": [
    "for square in squares:\n",
    "    print(square)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**（6）range()不是迭代器**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numbers = range(10)\n",
    "isinstance(numbers, Iterator)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "0\n",
      "True\n"
     ]
    },
    {
     "ename": "TypeError",
     "evalue": "'range' object is not an iterator",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-76-7c59bf859258>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnumbers\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m     \u001b[1;31m# 可索引\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m9\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mnumbers\u001b[0m\u001b[1;33m)\u001b[0m   \u001b[1;31m# 可存在计算\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 4\u001b[1;33m \u001b[0mnext\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mnumbers\u001b[0m\u001b[1;33m)\u001b[0m         \u001b[1;31m# 不可被next()调用\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: 'range' object is not an iterator"
     ]
    }
   ],
   "source": [
    "print(len(numbers))   # 有长度\n",
    "print(numbers[0])     # 可索引\n",
    "print(9 in numbers)   # 可存在计算\n",
    "next(numbers)         # 不可被next()调用"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "for number in numbers:\n",
    "    print(number)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "不会被耗尽"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "for number in numbers:\n",
    "    print(number)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "可以称range()为懒序列  \n",
    "  \n",
    "    它是一种序列\n",
    "      \n",
    "    但并不包含任何内存中的内容\n",
    "      \n",
    "    而是通过计算来回答问题"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 9.3.3 装饰器"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**1、需求的提出**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "（1）需要对已开发上线的程序添加某些功能\n",
    "    \n",
    "（2）不能对程序中函数的源代码进行修改\n",
    "  \n",
    "（3）不能改变程序中函数的调用方式"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**比如说，要统计每个函数的运行时间**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def f1():\n",
    "    pass\n",
    "\n",
    "\n",
    "def f2():\n",
    "    pass\n",
    "\n",
    "\n",
    "def f3():\n",
    "    pass\n",
    "\n",
    "f1()\n",
    "f2()\n",
    "f3()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**没问题，我们有装饰器！！！**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**2、函数对象**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "函数是Python中的第一类对象\n",
    "\n",
    "（1）可以把函数赋值给变量  \n",
    "  \n",
    "（2）对该变量进行调用，可实现原函数的功能"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'function'>\n"
     ]
    }
   ],
   "source": [
    "def square(x):\n",
    "    return x**2\n",
    "\n",
    "print(type(square))      # square 是function类的一个实例"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "25\n",
      "25\n"
     ]
    }
   ],
   "source": [
    "pow_2 = square          # 可以理解成给这个函数起了个别名pow_2\n",
    "print(pow_2(5))\n",
    "print(square(5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "可以将函数作为参数进行传递"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**3、高阶函数**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "（1）接收函数作为参数  \n",
    "  \n",
    "（2）或者返回一个函数  \n",
    "  \n",
    "   **满足上述条件之一的函数称之为高阶函数**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "64"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def square(x):\n",
    "    return x**2\n",
    "\n",
    "\n",
    "def pow_2(fun):\n",
    "    return fun\n",
    "\n",
    "\n",
    "f = pow_2(square)\n",
    "f(8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "print(f == square)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**4、 嵌套函数**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**在函数内部定义一个函数**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "outer is running\n",
      "inner is running\n"
     ]
    }
   ],
   "source": [
    "def outer():\n",
    "    print(\"outer is running\")\n",
    "    \n",
    "    def inner():\n",
    "        print(\"inner is running\")\n",
    "        \n",
    "    inner()\n",
    "\n",
    "\n",
    "outer()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**5、闭包**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<function outer.<locals>.inner at 0x000001BE11B1D730>\n"
     ]
    }
   ],
   "source": [
    "def outer():\n",
    "    x = 1\n",
    "    z = 10\n",
    "    \n",
    "    def inner():\n",
    "        y = x+100\n",
    "        return y, z\n",
    "        \n",
    "    return inner\n",
    "\n",
    "\n",
    "f = outer()                # 实际上f包含了inner函数本身+outer函数的环境\n",
    "print(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(<cell at 0x000001BE0FDE06D8: int object at 0x00007FF910D59340>, <cell at 0x000001BE0FDE0A98: int object at 0x00007FF910D59460>)\n",
      "1\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "print(f.__closure__)         # __closure__属性中包含了来自外部函数的信息\n",
    "for i in f.__closure__:\n",
    "    print(i.cell_contents)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(101, 10)\n"
     ]
    }
   ],
   "source": [
    "res = f()\n",
    "print(res)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**闭包：延伸了作用域的函数**  \n",
    "  \n",
    "**如果一个函数定义在另一个函数的作用域内，并且引用了外层函数的变量，则该函数称为闭包**\n",
    "  \n",
    "**闭包是由函数及其相关的引用环境组合而成的实体(即：闭包=函数+引用环境)**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 一旦在内层函数重新定义了相同名字的变量，则变量成为局部变量"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "ename": "UnboundLocalError",
     "evalue": "local variable 'x' referenced before assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mUnboundLocalError\u001b[0m                         Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-87-d2da1048af8b>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m     10\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     11\u001b[0m \u001b[0mf\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mouter\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 12\u001b[1;33m \u001b[0mf\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;32m<ipython-input-87-d2da1048af8b>\u001b[0m in \u001b[0;36minner\u001b[1;34m()\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      4\u001b[0m     \u001b[1;32mdef\u001b[0m \u001b[0minner\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 5\u001b[1;33m         \u001b[0mx\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mx\u001b[0m\u001b[1;33m+\u001b[0m\u001b[1;36m100\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      6\u001b[0m         \u001b[1;32mreturn\u001b[0m \u001b[0mx\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      7\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mUnboundLocalError\u001b[0m: local variable 'x' referenced before assignment"
     ]
    }
   ],
   "source": [
    "def outer():\n",
    "    x = 1\n",
    "    \n",
    "    def inner():\n",
    "        x = x+100\n",
    "        return x\n",
    "        \n",
    "    return inner\n",
    "\n",
    "\n",
    "f = outer()             \n",
    "f()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "nonlocal允许内嵌的函数来修改闭包变量"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "101"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def outer():\n",
    "    x = 1\n",
    "    \n",
    "    def inner():\n",
    "        nonlocal x\n",
    "        x = x+100\n",
    "        return x  \n",
    "    return inner\n",
    "\n",
    "\n",
    "f = outer()             \n",
    "f()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**6、一个简单的装饰器**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**嵌套函数实现**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "inner run\n",
      "f1 run\n",
      "f1 函数运行用时1.00秒\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "\n",
    "def timer(func):\n",
    "    \n",
    "    def inner():\n",
    "        print(\"inner run\")\n",
    "        start = time.time()\n",
    "        func()\n",
    "        end = time.time()\n",
    "        print(\"{} 函数运行用时{:.2f}秒\".format(func.__name__, (end-start)))\n",
    "    \n",
    "    return inner\n",
    "\n",
    "\n",
    "def f1():\n",
    "    print(\"f1 run\")\n",
    "    time.sleep(1)\n",
    "\n",
    "\n",
    "\n",
    "f1 = timer(f1)             # 包含inner()和timer的环境，如传递过来的参数func\n",
    "f1()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**语法糖**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "inner run\n",
      "f1 run\n",
      "f1 函数运行用时1.00秒\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "\n",
    "def timer(func):\n",
    "    \n",
    "    def inner():\n",
    "        print(\"inner run\")\n",
    "        start = time.time()\n",
    "        func()\n",
    "        end = time.time()\n",
    "        print(\"{} 函数运行用时{:.2f}秒\".format(func.__name__, (end-start)))\n",
    "    \n",
    "    return inner\n",
    "\n",
    "@timer                      # 相当于实现了f1 = timer(f1)\n",
    "def f1():\n",
    "    print(\"f1 run\")\n",
    "    time.sleep(1)\n",
    "    \n",
    "    \n",
    "f1()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**7、装饰有参函数**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "inner run\n",
      "f1 run\n",
      "f1 函数运行用时2.00秒\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "\n",
    "\n",
    "def timer(func):\n",
    "    \n",
    "    def inner(*args, **kwargs):\n",
    "        print(\"inner run\")\n",
    "        start = time.time()\n",
    "        func(*args, **kwargs)\n",
    "        end = time.time()\n",
    "        print(\"{} 函数运行用时{:.2f}秒\".format(func.__name__, (end-start)))\n",
    "    \n",
    "    return inner\n",
    "\n",
    "\n",
    "@timer                # 相当于实现了f1 = timer(f1)\n",
    "def f1(n):\n",
    "    print(\"f1 run\")\n",
    "    time.sleep(n)\n",
    "\n",
    "    \n",
    "f1(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "被装饰函数有返回值的情况"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "inner run\n",
      "f1 run\n",
      "f1 函数运行用时2.00秒\n",
      "wake up\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "\n",
    "\n",
    "def timer(func):\n",
    "    \n",
    "    def inner(*args, **kwargs):\n",
    "        print(\"inner run\")\n",
    "        start = time.time()\n",
    "        res = func(*args, **kwargs)\n",
    "        end = time.time()\n",
    "        print(\"{} 函数运行用时{:.2f}秒\".format(func.__name__, (end-start)))\n",
    "        return res\n",
    "    \n",
    "    return inner\n",
    "\n",
    "\n",
    "@timer                   # 相当于实现了f1 = timer(f1)\n",
    "def f1(n):\n",
    "    print(\"f1 run\")\n",
    "    time.sleep(n)\n",
    "    return \"wake up\"\n",
    "    \n",
    "res = f1(2)\n",
    "print(res)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**8、带参数的装饰器**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "装饰器本身要传递一些额外参数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 需求：有时需要统计绝对时间，有时需要统计绝对时间的2倍"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "inner run\n",
      "origin_inner run\n",
      "f1 run\n",
      "f1 函数运行用时1.00秒\n",
      "\n",
      "inner run\n",
      "double_inner run\n",
      "f2 run\n",
      "f2 函数运行双倍用时2.00秒\n"
     ]
    }
   ],
   "source": [
    "def timer(method):\n",
    "    \n",
    "    def outer(func):\n",
    "    \n",
    "        def inner(*args, **kwargs):\n",
    "            print(\"inner run\")\n",
    "            if method == \"origin\":\n",
    "                print(\"origin_inner run\")\n",
    "                start = time.time()\n",
    "                res = func(*args, **kwargs)\n",
    "                end = time.time()\n",
    "                print(\"{} 函数运行用时{:.2f}秒\".format(func.__name__, (end-start)))\n",
    "            elif method == \"double\":\n",
    "                print(\"double_inner run\")\n",
    "                start = time.time()\n",
    "                res = func(*args, **kwargs)\n",
    "                end = time.time()\n",
    "                print(\"{} 函数运行双倍用时{:.2f}秒\".format(func.__name__, 2*(end-start)))\n",
    "            return res\n",
    "    \n",
    "        return inner\n",
    "    \n",
    "    return outer\n",
    "\n",
    "\n",
    "@timer(method=\"origin\")  # 相当于timer = timer(method = \"origin\")   f1 = timer(f1)\n",
    "def f1():\n",
    "    print(\"f1 run\")\n",
    "    time.sleep(1)\n",
    "    \n",
    "    \n",
    "@timer(method=\"double\")\n",
    "def f2():\n",
    "    print(\"f2 run\")\n",
    "    time.sleep(1)\n",
    "\n",
    "\n",
    "f1()\n",
    "print()\n",
    "f2()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**理解闭包是关键！！！**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**9、何时执行装饰器**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 一装饰就执行，不必等调用"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "run\n",
      "run\n",
      "run\n"
     ]
    }
   ],
   "source": [
    "func_names=[]\n",
    "def find_function(func):\n",
    "    print(\"run\")\n",
    "    func_names.append(func)\n",
    "    return func\n",
    "\n",
    "\n",
    "@find_function\n",
    "def f1():\n",
    "    print(\"f1 run\")\n",
    "    \n",
    "\n",
    "@find_function\n",
    "def f2():\n",
    "    print(\"f2 run\")\n",
    "    \n",
    "\n",
    "@find_function\n",
    "def f3():\n",
    "    print(\"f3 run\")\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "f1\n",
      "f1 run\n",
      "\n",
      "f2\n",
      "f2 run\n",
      "\n",
      "f3\n",
      "f3 run\n",
      "\n"
     ]
    }
   ],
   "source": [
    "for func in func_names:\n",
    "    print(func.__name__)\n",
    "    func()\n",
    "    print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**10、回归本源**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 原函数的属性被掩盖了"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "inner\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "\n",
    "def timer(func):\n",
    "    def inner():\n",
    "        print(\"inner run\")\n",
    "        start = time.time()\n",
    "        func()\n",
    "        end = time.time()\n",
    "        print(\"{} 函数运行用时{:.2f}秒\".format(func.__name__, (end-start)))\n",
    "    \n",
    "    return inner\n",
    "\n",
    "@timer                # 相当于实现了f1 = timer(f1)\n",
    "def f1():\n",
    "    time.sleep(1)\n",
    "    print(\"f1 run\")\n",
    "\n",
    "print(f1.__name__)    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 回来"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "f1\n",
      "inner run\n",
      "f1 run\n",
      "f1 函数运行用时1.00秒\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "from functools import wraps\n",
    "\n",
    "def timer(func):\n",
    "    @wraps(func)\n",
    "    def inner():\n",
    "        print(\"inner run\")\n",
    "        start = time.time()\n",
    "        func()\n",
    "        end = time.time()\n",
    "        print(\"{} 函数运行用时{:.2f}秒\".format(func.__name__, (end-start)))\n",
    "    \n",
    "    return inner\n",
    "\n",
    "@timer                # 相当于实现了f1 = timer(f1)\n",
    "def f1():\n",
    "    time.sleep(1)\n",
    "    print(\"f1 run\")\n",
    "\n",
    "print(f1.__name__) \n",
    "f1()"
   ]
  }
 ],
 "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}