01_Python-Basic.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T06:55:10.200819Z",
     "start_time": "2020-02-01T06:55:10.196424Z"
    }
   },
   "source": [
    "Jupyter Notebook 介绍"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 第一个python程序"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:50.650134Z",
     "start_time": "2020-02-01T11:09:50.646675Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "你好，python\n"
     ]
    }
   ],
   "source": [
    "print('你好，python')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "获取帮助，例如我们想了解`print`函数：\n",
    "```python\n",
    "print?\n",
    "\n",
    ">>>\n",
    "Docstring:\n",
    "print(value, ..., sep=' ', end='\\n', file=sys.stdout, flush=False)\n",
    "\n",
    "Prints the values to a stream, or to sys.stdout by default.\n",
    "Optional keyword arguments:\n",
    "file:  a file-like object (stream); defaults to the current sys.stdout.\n",
    "sep:   string inserted between values, default a space.\n",
    "end:   string appended after the last value, default a newline.\n",
    "flush: whether to forcibly flush the stream.\n",
    "Type:      builtin_function_or_method\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:50.660315Z",
     "start_time": "2020-02-01T11:09:50.656892Z"
    }
   },
   "outputs": [],
   "source": [
    "#print??"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:50.671443Z",
     "start_time": "2020-02-01T11:09:50.662355Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function print in module builtins:\n",
      "\n",
      "print(...)\n",
      "    print(value, ..., sep=' ', end='\\n', file=sys.stdout, flush=False)\n",
      "    \n",
      "    Prints the values to a stream, or to sys.stdout by default.\n",
      "    Optional keyword arguments:\n",
      "    file:  a file-like object (stream); defaults to the current sys.stdout.\n",
      "    sep:   string inserted between values, default a space.\n",
      "    end:   string appended after the last value, default a newline.\n",
      "    flush: whether to forcibly flush the stream.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(print)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:50.682006Z",
     "start_time": "2020-02-01T11:09:50.673799Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "你好，python\n"
     ]
    }
   ],
   "source": [
    "# 注意sep后的'，'是中文字符！\n",
    "print('你好','python', sep='，')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 赋值操作\n",
    "注意我们并没有给`a`和`b`指定类型（整数、字符串）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:50.697322Z",
     "start_time": "2020-02-01T11:09:50.683837Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = 3\n",
    "\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:50.706324Z",
     "start_time": "2020-02-01T11:09:50.699214Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = 2*a\n",
    "\n",
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:50.715019Z",
     "start_time": "2020-02-01T11:09:50.708189Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`b`原来是`int`型（整数），现在直接变成了`str`型（字符串）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:50.724533Z",
     "start_time": "2020-02-01T11:09:50.717869Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = 'hello'\n",
    "type(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:50.733409Z",
     "start_time": "2020-02-01T11:09:50.726805Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'hellohello'"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b+b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:50.742564Z",
     "start_time": "2020-02-01T11:09:50.735408Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'hellohello'"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2*b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 基本类型"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 数值 Numerical types"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:50.752136Z",
     "start_time": "2020-02-01T11:09:50.744064Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n",
      "<class 'float'>\n",
      "<class 'complex'>\n",
      "<class 'bool'>\n"
     ]
    }
   ],
   "source": [
    "a = 4\n",
    "b = 2.1\n",
    "c = 1.5 + 0.5j\n",
    "d = True\n",
    "\n",
    "print(type(a))\n",
    "print(type(b))\n",
    "print(type(c))\n",
    "print(type(d))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:50.763010Z",
     "start_time": "2020-02-01T11:09:50.753912Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a == 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 容器 Containers\n",
    "\n",
    "### 列表 List"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:50.773796Z",
     "start_time": "2020-02-01T11:09:50.764773Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['red', 'blue', 'green', 'black', 'white']"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "colors = ['red', 'blue', 'green', 'black', 'white']\n",
    "\n",
    "colors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:50.782897Z",
     "start_time": "2020-02-01T11:09:50.775262Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "list"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(colors)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "注意下标从0开始"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:50.793462Z",
     "start_time": "2020-02-01T11:09:50.784650Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['green', 'black']"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "colors[2:4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:50.802419Z",
     "start_time": "2020-02-01T11:09:50.795089Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'white'"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "colors[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:50.811587Z",
     "start_time": "2020-02-01T11:09:50.804155Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['r', 'blue', 'green', 'black', 'white']"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "colors[0] = 'r' \n",
    "colors"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### String"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:50.822501Z",
     "start_time": "2020-02-01T11:09:50.813303Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'hello'"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = 'hello'\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A string is an immutable object and it is not possible to modify its contents. One may however create new strings from the original one."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:50.898082Z",
     "start_time": "2020-02-01T11:09:50.825504Z"
    }
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'str' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-19-f15f66b8b5bc>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0ma\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'1'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: 'str' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "a[2] = '1'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-01-16T09:11:42.294605Z",
     "start_time": "2020-01-16T09:11:42.286578Z"
    }
   },
   "source": [
    "### 字典 Dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:50.901547Z",
     "start_time": "2020-02-01T11:09:50.726Z"
    }
   },
   "outputs": [],
   "source": [
    "tel = {'emmanuelle': 5752, 'sebastian': 5578}\n",
    "tel"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:50.902740Z",
     "start_time": "2020-02-01T11:09:50.729Z"
    }
   },
   "outputs": [],
   "source": [
    "tel['francis'] = 5915\n",
    "tel"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:50.903757Z",
     "start_time": "2020-02-01T11:09:50.733Z"
    }
   },
   "outputs": [],
   "source": [
    "tel['emmanuelle'] = 0\n",
    "tel"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-01-16T09:18:08.523224Z",
     "start_time": "2020-01-16T09:18:08.506939Z"
    }
   },
   "source": [
    "字典可以存储不同类型的变量"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:50.904841Z",
     "start_time": "2020-02-01T11:09:50.738Z"
    }
   },
   "outputs": [],
   "source": [
    "d = {'a':1, 'b':2, 3:'hello'}\n",
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exception\n",
    "```\n",
    "1/0\n",
    "\n",
    "\n",
    "1 + 'e'\n",
    "\n",
    "\n",
    "d ={'1':1, '2':2}\n",
    "d['3']\n",
    "\n",
    "\n",
    "l = [1, 2, 3]\n",
    "l[4]\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:50.905773Z",
     "start_time": "2020-02-01T11:09:50.744Z"
    }
   },
   "outputs": [],
   "source": [
    "#1/0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:50.906863Z",
     "start_time": "2020-02-01T11:09:50.748Z"
    }
   },
   "outputs": [],
   "source": [
    "class Student(object):\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "\n",
    "    def set_age(self, age):\n",
    "        self.age = age\n",
    "\n",
    "    def set_major(self, major):\n",
    "        self.major = major"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:50.908074Z",
     "start_time": "2020-02-01T11:09:50.752Z"
    }
   },
   "outputs": [],
   "source": [
    "anna = Student('anna')\n",
    "anna.set_age(21)\n",
    "anna.set_age('physics')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:50.909070Z",
     "start_time": "2020-02-01T11:09:50.756Z"
    }
   },
   "outputs": [],
   "source": [
    "class MasterStudent(Student):\n",
    "    internship = 'mandatory, from March to June'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:50.910232Z",
     "start_time": "2020-02-01T11:09:50.759Z"
    }
   },
   "outputs": [],
   "source": [
    "james = MasterStudent('james')\n",
    "james.internship"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "### 正方形：\n",
    "\n",
    "$\\text{面积} = \\text{边长} \\times \\text{边长}$\n",
    "\n",
    "$\\text{周长} = \\text{边长} \\times 4$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:50.911315Z",
     "start_time": "2020-02-01T11:09:50.764Z"
    }
   },
   "outputs": [],
   "source": [
    "class Square:\n",
    "    def __init__(self, length):\n",
    "        self.length = length\n",
    "    \n",
    "    def area(self):\n",
    "        return self.length * self.length\n",
    "    \n",
    "    def perimeter(self):\n",
    "        return 4 * self.length"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:50.912260Z",
     "start_time": "2020-02-01T11:09:50.767Z"
    },
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "square = Square(10)\n",
    "dir(square)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:50.913396Z",
     "start_time": "2020-02-01T11:09:50.770Z"
    }
   },
   "outputs": [],
   "source": [
    "square.area()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:50.914457Z",
     "start_time": "2020-02-01T11:09:50.774Z"
    }
   },
   "outputs": [],
   "source": [
    "square.perimeter()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 长方形：\n",
    "\n",
    "$\\text{面积} = \\text{长} \\times \\text{宽}$\n",
    "\n",
    "$\\text{周长} = (\\text{长} + \\text{宽}) \\times 2$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:50.915296Z",
     "start_time": "2020-02-01T11:09:50.778Z"
    }
   },
   "outputs": [],
   "source": [
    "class Rectangle:\n",
    "    def __init__(self, length, width):\n",
    "        self.length = length\n",
    "        self.width = width\n",
    "    \n",
    "    def area(self):\n",
    "        return self.length * self.width\n",
    "    \n",
    "    def perimeter(self):\n",
    "        return 2 * (self.length + self.width)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:50.916221Z",
     "start_time": "2020-02-01T11:09:50.783Z"
    }
   },
   "outputs": [],
   "source": [
    "rectangle = Rectangle(8, 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:50.917236Z",
     "start_time": "2020-02-01T11:09:50.788Z"
    }
   },
   "outputs": [],
   "source": [
    "rectangle.area()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:50.918425Z",
     "start_time": "2020-02-01T11:09:50.792Z"
    }
   },
   "outputs": [],
   "source": [
    "rectangle.perimeter()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 衍生的正方形"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:50.919598Z",
     "start_time": "2020-02-01T11:09:50.797Z"
    }
   },
   "outputs": [],
   "source": [
    "class Square(Rectangle):\n",
    "    def __init__(self, length):\n",
    "        super().__init__(length, length)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:50.920427Z",
     "start_time": "2020-02-01T11:09:50.801Z"
    },
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "square = Square(6)\n",
    "dir(square)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:50.921480Z",
     "start_time": "2020-02-01T11:09:50.805Z"
    }
   },
   "outputs": [],
   "source": [
    "square.__class__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:50.922488Z",
     "start_time": "2020-02-01T11:09:50.809Z"
    }
   },
   "outputs": [],
   "source": [
    "square.__class__.__bases__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python 进阶\n",
    "## List Comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:50.923402Z",
     "start_time": "2020-02-01T11:09:50.813Z"
    }
   },
   "outputs": [],
   "source": [
    "list_a = [1, 2, 3, 4]\n",
    "list_a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:50.924315Z",
     "start_time": "2020-02-01T11:09:50.816Z"
    }
   },
   "outputs": [],
   "source": [
    "for i in list_a:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:50.925299Z",
     "start_time": "2020-02-01T11:09:50.820Z"
    }
   },
   "outputs": [],
   "source": [
    "[i for i in list_a]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:50.926378Z",
     "start_time": "2020-02-01T11:09:50.824Z"
    },
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "[i**2 for i in list_a]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lambda"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example: 求$\\pi$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$\n",
    "\\pi=2 \\prod_{i=1}^{\\infty} \\frac{4 i^{2}}{4 i^{2}-1}\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:50.927589Z",
     "start_time": "2020-02-01T11:09:50.830Z"
    }
   },
   "outputs": [],
   "source": [
    "pi = 2\n",
    "for i in range(1, 100):\n",
    "    pi = pi * 4 * (i**2) / (4*i**2-1)\n",
    "\n",
    "print(pi)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:50.928654Z",
     "start_time": "2020-02-01T11:09:50.834Z"
    }
   },
   "outputs": [],
   "source": [
    "fun = lambda x : 4*x**2/(4*x**2-1)\n",
    "pi = 2\n",
    "\n",
    "for i in range(1, 10000):\n",
    "    pi = pi * fun(i)\n",
    "\n",
    "print(pi)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Unpacking"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:50.929542Z",
     "start_time": "2020-02-01T11:09:50.838Z"
    }
   },
   "outputs": [],
   "source": [
    "list_A = [1, 2, 3]\n",
    "\n",
    "print(list_A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:50.930282Z",
     "start_time": "2020-02-01T11:09:50.841Z"
    }
   },
   "outputs": [],
   "source": [
    "print(*list_A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:50.930914Z",
     "start_time": "2020-02-01T11:09:50.844Z"
    }
   },
   "outputs": [],
   "source": [
    "dict_B = {'name1':'David', 'name2':'Queen'}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Variable number of parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:50.932065Z",
     "start_time": "2020-02-01T11:09:50.847Z"
    }
   },
   "outputs": [],
   "source": [
    "def varibale_args(*args, **kwargs):\n",
    "    print('args is', args)\n",
    "    print('kwargs is', kwargs)\n",
    "\n",
    "varibale_args('one', 'two', x=1, y=2, z=3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example 1: 求和"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:50.933187Z",
     "start_time": "2020-02-01T11:09:50.850Z"
    },
    "code_folding": []
   },
   "outputs": [],
   "source": [
    "list_A = [1, 2, 3]\n",
    "\n",
    "def sum(a, b, c):\n",
    "    return a+b+c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:50.934105Z",
     "start_time": "2020-02-01T11:09:50.855Z"
    }
   },
   "outputs": [],
   "source": [
    "sum(list_A[0], list_A[1], list_A[2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:50.935101Z",
     "start_time": "2020-02-01T11:09:50.859Z"
    }
   },
   "outputs": [],
   "source": [
    "sum(*list_A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example 2: 求和2\n",
    "如果还有`list_B = [1, 2, 3, 4, 5]`, `list_C = [1, 2, 5]`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:50.936100Z",
     "start_time": "2020-02-01T11:09:50.864Z"
    }
   },
   "outputs": [],
   "source": [
    "def my_sum(*args):\n",
    "    result = 0\n",
    "    for x in args:\n",
    "        result += x\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:50.937297Z",
     "start_time": "2020-02-01T11:09:50.867Z"
    }
   },
   "outputs": [],
   "source": [
    "list_B = [1, 2, 3, 4, 5]\n",
    "list_C = [1, 2, 5]\n",
    "\n",
    "my_sum(*list_A, *list_B, *list_C)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example 3: 快速合并"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:50.938325Z",
     "start_time": "2020-02-01T11:09:50.871Z"
    }
   },
   "outputs": [],
   "source": [
    "my_first_list = [1, 2, 3]\n",
    "my_second_list = [4, 5, 6]\n",
    "\n",
    "merged_list = {*my_first_list, *my_second_list}\n",
    "\n",
    "merged_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:50.939320Z",
     "start_time": "2020-02-01T11:09:50.874Z"
    }
   },
   "outputs": [],
   "source": [
    "my_first_dict = {\"A\": 1, \"B\": 2}\n",
    "my_second_dict = {\"C\": 3, \"D\": 4}\n",
    "\n",
    "merged_dict = {**my_first_dict, **my_second_dict}\n",
    "\n",
    "merged_dict"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "unpacking的用途远远不止这些!!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### isstance()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Iterators, generator expressions and generators\n",
    "\n",
    "应用场景：\n",
    "1. 按需生成数据\n",
    "\n",
    "2. 实现异步：某个事情执行一部分，另一部分在某个事件发生后再执行\n",
    "  \n",
    "\n",
    "### Iterators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:50.940242Z",
     "start_time": "2020-02-01T11:09:50.878Z"
    }
   },
   "outputs": [],
   "source": [
    "nums = [1,2,3]\n",
    "it = iter(nums)\n",
    "it"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:50.941352Z",
     "start_time": "2020-02-01T11:09:50.882Z"
    }
   },
   "outputs": [],
   "source": [
    "next(it)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:50.942270Z",
     "start_time": "2020-02-01T11:09:50.885Z"
    }
   },
   "outputs": [],
   "source": [
    "next(it)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:50.943250Z",
     "start_time": "2020-02-01T11:09:50.888Z"
    }
   },
   "outputs": [],
   "source": [
    "next(it)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:50.944425Z",
     "start_time": "2020-02-01T11:09:50.890Z"
    }
   },
   "outputs": [],
   "source": [
    "#next(it)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Example：读取文件\n",
    "有时候要读取得文件非常大，不能全部载入内存（或者载入时间非常慢），此时就体现出iterators的优势"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:50.945323Z",
     "start_time": "2020-02-01T11:09:50.894Z"
    }
   },
   "outputs": [],
   "source": [
    "f = open('student.txt')\n",
    "next(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:51.052490Z",
     "start_time": "2020-02-01T11:09:51.047403Z"
    }
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'f' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-20-aff1dd02a623>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mnext\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'f' is not defined"
     ]
    }
   ],
   "source": [
    "next(f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Generators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:51.053755Z",
     "start_time": "2020-02-01T11:09:50.902Z"
    }
   },
   "outputs": [],
   "source": [
    "def gen_example():\n",
    " \n",
    "    print ('before any yield')\n",
    " \n",
    "    yield 'first yield'\n",
    " \n",
    "    print ('between yields')\n",
    " \n",
    "    yield 'second yield'\n",
    " \n",
    "    print ('no yield anymore')\n",
    "\n",
    "g = gen_example()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:51.054381Z",
     "start_time": "2020-02-01T11:09:50.905Z"
    }
   },
   "outputs": [],
   "source": [
    "next(g)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:51.055508Z",
     "start_time": "2020-02-01T11:09:50.908Z"
    }
   },
   "outputs": [],
   "source": [
    "next(g)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:51.056266Z",
     "start_time": "2020-02-01T11:09:50.912Z"
    },
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "next(g)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Example: 斐波拉契数列（Fibonacci）\n",
    "著名的斐波拉契数列除第一个和第二个数外，任意一个数都可由前两个数相加得到：\n",
    "`1, 1, 2, 3, 5, 8, 13, 21, 34, ...`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:51.057682Z",
     "start_time": "2020-02-01T11:09:50.916Z"
    }
   },
   "outputs": [],
   "source": [
    "def fib1(num):\n",
    "    list_fib = []\n",
    "    a, b = 0, 1\n",
    "    for i in range(num):\n",
    "        list_fib.append(b)\n",
    "        a, b = b, a+b\n",
    "    return list_fib\n",
    "\n",
    "fibs = fib1(10)\n",
    "fibs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:51.058675Z",
     "start_time": "2020-02-01T11:09:50.920Z"
    }
   },
   "outputs": [],
   "source": [
    "def fib2(num): \n",
    "    a, b = 0, 1\n",
    "    for i in range(num):\n",
    "        yield b\n",
    "        a, b = b, a + b \n",
    "\n",
    "fibs = fib2(10)\n",
    "[i for i in fibs]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:51.059680Z",
     "start_time": "2020-02-01T11:09:50.923Z"
    }
   },
   "outputs": [],
   "source": [
    "import subprocess, os\n",
    "def get_mem():\n",
    "    res = subprocess.check_output(['ps', 'u', '-p', str(os.getpid())])\n",
    "    return int(str(res).split()[15]) / 1e3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:51.060650Z",
     "start_time": "2020-02-01T11:09:50.927Z"
    }
   },
   "outputs": [],
   "source": [
    "del fibs\n",
    "mem = get_mem()\n",
    "\n",
    "fibs = fib1(10000)\n",
    "print('increased memory: %f MB'%(get_mem()-mem))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:51.061578Z",
     "start_time": "2020-02-01T11:09:50.931Z"
    }
   },
   "outputs": [],
   "source": [
    "del fibs\n",
    "mem = get_mem()\n",
    "fibs = fib2(10000) \n",
    "print('increased memory: %f MB'%(get_mem()-mem))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Decorators\n",
    "\n",
    "This amazing feature appeared in the language almost apologetically and with concern that it might not be\n",
    "that useful.\n",
    "> Bruce Eckel — An Introduction to Python Decorators\n",
    "\n",
    "\n",
    "装饰器(decorator)是一种高级Python语法。装饰器可以对一个函数、方法或者类进行加工。在Python中，我们有多种方法对函数和类进行加工，比如在Python闭包中，我们见到函数对象作为某一个函数的返回结果。相对于其它方式，装饰器语法简单，代码可读性高。因此，装饰器在Python项目中有广泛的应用。\n",
    "\n",
    "\n",
    "应用场景：Replacing or tweaking the original object\n",
    "\n",
    "\n",
    "语法：\n",
    "```python\n",
    "@decorator # 2\n",
    "def function(): # 1\n",
    "    pass\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:51.062456Z",
     "start_time": "2020-02-01T11:09:50.935Z"
    }
   },
   "outputs": [],
   "source": [
    "%reset -f"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:51.063256Z",
     "start_time": "2020-02-01T11:09:50.939Z"
    }
   },
   "outputs": [],
   "source": [
    "def generate_fib(num):\n",
    "    list_fib = []\n",
    "    a, b = 0, 1\n",
    "    for i in range(num):\n",
    "        list_fib.append(b)\n",
    "        a, b = b, a+b\n",
    "    return list_fib\n",
    "\n",
    "generate_fib(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:51.064035Z",
     "start_time": "2020-02-01T11:09:50.943Z"
    }
   },
   "outputs": [],
   "source": [
    "import time\n",
    "time.ctime()\n",
    "time.time()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-01-19T09:01:33.060543Z",
     "start_time": "2020-01-19T09:01:33.057234Z"
    }
   },
   "source": [
    "如果我们想测运行的时间？"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:51.064876Z",
     "start_time": "2020-02-01T11:09:50.947Z"
    }
   },
   "outputs": [],
   "source": [
    "start = time.time()\n",
    "res = generate_fib(10)\n",
    "time_cost = (time.time() - start)*1000 # ms\n",
    "print('%.3f ms'%(time_cost))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如果我们还想测别的函数运行时间，难道将以下代码重复很多遍？\n",
    "```python\n",
    "start = time.time()\n",
    "...\n",
    "time_cost = (time.time() - start)*1000 # ms\n",
    "print('%.3f ms'%(time_cost))\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:51.065712Z",
     "start_time": "2020-02-01T11:09:50.951Z"
    }
   },
   "outputs": [],
   "source": [
    "def print_time_A(func, arg1):\n",
    "    start = time.time()\n",
    "    res = func(arg1)\n",
    "    time_cost = (time.time() - start)*1000 # ms\n",
    "    print('const %.3f ms'%(time_cost))\n",
    "    return res\n",
    "\n",
    "print_time_A(generate_fib, 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如果测量的函数有两个参数怎么办？\n",
    "```python\n",
    "def print_time_A2(func, arg1, arg2):\n",
    "def print_time_A3(func, *args):\n",
    "```\n",
    "\n",
    "如果测量的函数的参数改了怎么办？\n",
    "\n",
    "这时就轮到decorator上场了："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:51.066556Z",
     "start_time": "2020-02-01T11:09:50.955Z"
    }
   },
   "outputs": [],
   "source": [
    "def simple_decorator(function):\n",
    "    print(\"doing decoration\")\n",
    "    return function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "装饰`generate_fib`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:51.067563Z",
     "start_time": "2020-02-01T11:09:50.958Z"
    }
   },
   "outputs": [],
   "source": [
    "@simple_decorator\n",
    "def generate_fib():\n",
    "    print(\"inside function\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:51.068552Z",
     "start_time": "2020-02-01T11:09:50.961Z"
    }
   },
   "outputs": [],
   "source": [
    "generate_fib()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`simple_decorator`在执行时候并没有做任何事！"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:51.069456Z",
     "start_time": "2020-02-01T11:09:50.964Z"
    }
   },
   "outputs": [],
   "source": [
    "def decorator_with_arguments(arg):\n",
    "    print(\"defining the decorator\")\n",
    "    def _decorator(function):\n",
    "        # in this inner function, arg is available too\n",
    "        print(\"doing decoration, %r \" % arg)\n",
    "        return function\n",
    "    return _decorator"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "此时将`function`也就是下面的`generate_fib`替换成了`_decorator`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:51.070328Z",
     "start_time": "2020-02-01T11:09:50.968Z"
    }
   },
   "outputs": [],
   "source": [
    "@simple_decorator\n",
    "def generate_fib():\n",
    "    print(\"inside function\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "可以看到在执行`_decorator`的过程中调用了`generate_fib`\n",
    "\n",
    "下面我们做些有用的事"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:51.071183Z",
     "start_time": "2020-02-01T11:09:50.972Z"
    }
   },
   "outputs": [],
   "source": [
    "def print_time_dec(func):\n",
    "    def dec(num):\n",
    "        start = time.time()\n",
    "        res = func(num)\n",
    "        time_cost = (time.time() - start)*1000 # ms\n",
    "        print('cost %.3f ms'%(time_cost))\n",
    "    return dec"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```python\n",
    "@decorator # 2\n",
    "def function(): # 1\n",
    "    pass\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:51.072082Z",
     "start_time": "2020-02-01T11:09:50.976Z"
    }
   },
   "outputs": [],
   "source": [
    "@print_time_dec\n",
    "def generate_fib(num):\n",
    "    list_fib = []\n",
    "    a, b = 0, 1\n",
    "    for i in range(num):\n",
    "        list_fib.append(b)\n",
    "        a, b = b, a+b\n",
    "    return list_fib"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:51.072943Z",
     "start_time": "2020-02-01T11:09:50.979Z"
    }
   },
   "outputs": [],
   "source": [
    "generate_fib(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "为了通用，我们可以进一步优化：\n",
    "```python\n",
    "def print_time_dec(func):\n",
    "    def dec(*args, **kwargs):\n",
    "       start = time.time()\n",
    "       res =  func(*args, **kwargs)\n",
    "       time_cost = (time.time() - start)*1000 # ms\n",
    "       print('cost %.3f ms'%(time_cost))\n",
    "    return dec\n",
    "```\n",
    "\n",
    "还记得`*args, **kwargs`吗？（参考Unpacking章节），这两个参数可以帮助decorator接受含任意式样参数的函数，但是缺点也很明显，就是失去了可读性。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Examples: Deprecation of functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-01-19T08:54:07.978151Z",
     "start_time": "2020-01-19T08:54:07.974362Z"
    }
   },
   "source": [
    "Let’s say we want to print a deprecation warning on stderr on the first invocation of a function we don’t like\n",
    "anymore. If we don’t want to modify the function, we can use a decorator:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:51.073786Z",
     "start_time": "2020-02-01T11:09:50.983Z"
    }
   },
   "outputs": [],
   "source": [
    "def deprecated(func):\n",
    "    \"\"\"Print a deprecation warning once on first use of the function.\n",
    "\n",
    "        >>> @deprecated # doctest: +SKIP\n",
    "        ... def f():\n",
    "        ...     pass\n",
    "\n",
    "        >>> f() # doctest: +SKIP\n",
    "        f is deprecated\n",
    "    \"\"\"\n",
    "    count = [0]\n",
    "    def wrapper(*args, **kwargs):\n",
    "        count[0] += 1\n",
    "        if count[0] == 1:\n",
    "            print('Warning:', func.__name__, 'is deprecated!')\n",
    "        return func(*args, **kwargs)\n",
    "    return wrapper"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:51.074661Z",
     "start_time": "2020-02-01T11:09:50.986Z"
    }
   },
   "outputs": [],
   "source": [
    "@deprecated\n",
    "def generate_fib(num):\n",
    "    list_fib = []\n",
    "    a, b = 0, 1\n",
    "    for i in range(num):\n",
    "        list_fib.append(b)\n",
    "        a, b = b, a+b\n",
    "    return list_fib\n",
    "\n",
    "generate_fib(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "第二次执行就不会出现警告信息了"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:51.075517Z",
     "start_time": "2020-02-01T11:09:50.990Z"
    }
   },
   "outputs": [],
   "source": [
    "generate_fib(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:51.076396Z",
     "start_time": "2020-02-01T11:09:50.993Z"
    }
   },
   "outputs": [],
   "source": [
    "def retry_on_failure(count=10): # <- default count as 10\n",
    "    def retry_function(function):\n",
    "        def wrapper(*args, **kwargs):\n",
    "            while count > 0:\n",
    "                try:\n",
    "                   func_response = function(view, request, *args, **kwargs)\n",
    "                   break  # <- breaks the while loop if success \n",
    "                except:\n",
    "                   count -= 1\n",
    "                   func_response = None\n",
    "            return func_response\n",
    "        return wrapper\n",
    "    return retry_function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Example：A plugin registration system\n",
    "平时使用软件时候经常会通过插件来丰富功能，我们来实现一个邮件签名的插件。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:51.077375Z",
     "start_time": "2020-02-01T11:09:50.997Z"
    }
   },
   "outputs": [],
   "source": [
    "class MailSender(object):\n",
    "    PLUGINS = []\n",
    "    def process(self, text):\n",
    "        for plugin in self.PLUGINS:\n",
    "            text = plugin(text)\n",
    "        return text\n",
    "    \n",
    "    @classmethod\n",
    "    def plugin(cls, plugin):\n",
    "        cls.PLUGINS.append(plugin())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:51.078178Z",
     "start_time": "2020-02-01T11:09:51.000Z"
    }
   },
   "outputs": [],
   "source": [
    "mail = MailSender()\n",
    "\n",
    "message = \\\n",
    "\"\"\"\n",
    "Hi,\n",
    "\n",
    "...\n",
    "...\n",
    "\"\"\"\n",
    "\n",
    "print(mail.process(message))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:51.079254Z",
     "start_time": "2020-02-01T11:09:51.003Z"
    }
   },
   "outputs": [],
   "source": [
    "@MailSender.plugin\n",
    "class Signature(object):\n",
    "    def __call__(self, text):\n",
    "        text = text + \"\"\"\\n-- From 哆啦壹萌\"\"\"\n",
    "        return text"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:51.080187Z",
     "start_time": "2020-02-01T11:09:51.006Z"
    }
   },
   "outputs": [],
   "source": [
    "print(mail.process(message))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:51.081381Z",
     "start_time": "2020-02-01T11:09:51.009Z"
    }
   },
   "outputs": [],
   "source": [
    "print(\"a\\nb\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 思考题：带参数的decorator\n",
    "下面的decorator有什么用？请动手试一试。\n",
    "\n",
    "```python\n",
    "def replacing_decorator_with_args(arg):\n",
    "    print(\"defining the decorator\")\n",
    "    def _decorator(function):\n",
    "        # in this inner function, arg is available too\n",
    "        print(\"doing decoration, %r \" % arg)\n",
    "        def _wrapper(*args, **kwargs):\n",
    "            print(\"inside wrapper, %r %r \" % (args, kwargs))\n",
    "            return function(*args, **kwargs)\n",
    "        return _wrapper\n",
    "    return _decorator\n",
    "```\n",
    "提示，参考下面的使用样例：\n",
    "```python\n",
    "@replacing_decorator_with_args(\"abc\")\n",
    "def function(*args, **kwargs):\n",
    "    print(\"inside function, %r %r \" % (args, kwargs))\n",
    "    return 14\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-01-19T11:12:08.414280Z",
     "start_time": "2020-01-19T11:12:08.406462Z"
    }
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 其他"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:51.082220Z",
     "start_time": "2020-02-01T11:09:51.020Z"
    }
   },
   "outputs": [],
   "source": [
    "%who"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:51.082990Z",
     "start_time": "2020-02-01T11:09:51.023Z"
    }
   },
   "outputs": [],
   "source": [
    "%whos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:51.083798Z",
     "start_time": "2020-02-01T11:09:51.026Z"
    }
   },
   "outputs": [],
   "source": [
    "np.array([1,3])\n",
    "dir(list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-01T11:09:51.084836Z",
     "start_time": "2020-02-01T11:09:51.030Z"
    }
   },
   "outputs": [],
   "source": [
    "np?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Numpy\n",
    "For collections of numerical data that all have the same type, it is often more efficient to use the array\n",
    "type provided by the numpy module. A NumPy array is a chunk of memory containing fixed-sized items. With\n",
    "NumPy arrays, operations on elements can be faster because elements are regularly spaced in memory and\n",
    "more operations are performed through specialized C functions instead of Python loops."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "378px"
   },
   "toc_section_display": true,
   "toc_window_display": true
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}