Python 入門 - Part 3.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 前情提要\n",
    "\n",
    "* List\n",
    "    - List Methods\n",
    "        + list.append\n",
    "        + list.reverse\n",
    "        + list.sort\n",
    "        + list.remove\n",
    "        + list.pop\n",
    "        + list.index\n",
    "        + list.insert\n",
    "        + list.count\n",
    "* List Comprehension\n",
    "    - 更方便地建立 list      \n",
    "* More String Operations\n",
    "    - A 是否是 B 的子字串\n",
    "    - 把 B 用空格切割\n",
    "    - B 是以 \"This\" 開頭的？\n",
    "    - 找到子字串的位置\n",
    "    - 字串重複\n",
    "    - 字串連接\n",
    "    - 字串用特定分隔符號連接\n",
    "* Regular Expressions\n",
    "* Import\n",
    "* 自己寫 Module\n",
    "* Unpack\n",
    "    - 拆解 & 打包\n",
    "    - `*` : list\n",
    "    - `**` : dictionary\n",
    "* Misc\n",
    "    - sorted\n",
    "    - any\n",
    "    - all\n",
    "    - sum\n",
    "    - max\n",
    "    - min\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Scope\n",
    "\n",
    "namespace & environment\n",
    "\n",
    "## Namespace\n",
    "\n",
    "#### LEGB rule\n",
    "\n",
    "```\n",
    "built-in\n",
    "    |\n",
    "    └── Global\n",
    "            |\n",
    "            └── Enclosing\n",
    "                    | \n",
    "                    └── Local  \n",
    "\n",
    "```\n",
    "\n",
    "## Environment\n",
    "\n",
    "將不同的 namespace 串起來，一段 code 實際執行時看的環境"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## for example\n",
    "\n",
    "#### Recursive\n",
    "```\n",
    "   =====================  ### namespace ###  ============================\n",
    "   built-in namespace (built-in functions)\n",
    "   |\n",
    "   └──Global namespace (def fact(n):)  \n",
    "   =====================  ### 每次遞迴  ###   ============================\n",
    "       |                                                   |\n",
    "       └──local namespace ( return n (=3) * fact(n-1) )    └── local namespace ( return n (=2) * fact(n-1) ) ...\n",
    "       \n",
    "   =====================  ### each environment ###  ============================\n",
    "                ∆                                                    ∆\n",
    "                |                                                    |\n",
    "                └── environment (0)                ===>              └── environment (1)                ......\n",
    "\n",
    "```\n",
    "                "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "builtin_function_or_method"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(len([3,3,4,5]))  #build-in len function\n",
    "type(len)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len = 5   # assign 5 to global variable 'len\n",
    "print(len)\n",
    "type(len)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "local len\n",
      "<class 'str'>\n"
     ]
    }
   ],
   "source": [
    "def foo1():\n",
    "    len  = \"local len\"\n",
    "    print(len)\n",
    "    print(type(len))\n",
    "\n",
    "foo1()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "len in bar\n",
      "len in foo\n"
     ]
    }
   ],
   "source": [
    "def foo():\n",
    "    len = \"len in foo\"   \n",
    "    def bar():\n",
    "        len = \"len in bar\" #local 變數\n",
    "        print(len)\n",
    "    bar()\n",
    "    print(len)\n",
    "    \n",
    "foo()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "len in foo\n",
      "len in foo\n"
     ]
    }
   ],
   "source": [
    "def foo():\n",
    "    len = \"len in foo\"   \n",
    "    def bar():\n",
    "        print(len)\n",
    "    bar()\n",
    "    print(len)\n",
    "    \n",
    "foo()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## del\n",
    "\n",
    "刪除綁定關係"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "<built-in function len>\n"
     ]
    }
   ],
   "source": [
    "print(len)\n",
    "del len    # 刪除 len = 5 的綁定\n",
    "print(len)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## global\n",
    "\n",
    "宣告變數為 global"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = 3\n",
    "def foo1():\n",
    "    global a \n",
    "    a = 5\n",
    "foo1()\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## nonlocal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "len in foo\n",
      "len in bar\n",
      "len in bar\n"
     ]
    }
   ],
   "source": [
    "def foo():\n",
    "    len = \"len in foo\"   # nonlocal 的 len\n",
    "    def bar():\n",
    "        nonlocal len\n",
    "        print(len)\n",
    "        len = \"len in bar\"\n",
    "        print(len)\n",
    "    bar()\n",
    "    print(len)\n",
    "    \n",
    "foo()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "global len\n"
     ]
    }
   ],
   "source": [
    "len = \"global len\"\n",
    "def foo():\n",
    "    def bar():\n",
    "        len = \"len in bar\"    \n",
    "    bar()\n",
    "    print(len)\n",
    "    \n",
    "foo()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "len in foo\n"
     ]
    },
    {
     "ename": "UnboundLocalError",
     "evalue": "local variable 'len' referenced before assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mUnboundLocalError\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-10-c4656ac713af>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     10\u001b[0m     \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     11\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 12\u001b[0;31m \u001b[0mfoo\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-10-c4656ac713af>\u001b[0m in \u001b[0;36mfoo\u001b[0;34m()\u001b[0m\n\u001b[1;32m      8\u001b[0m         \u001b[0;32mdel\u001b[0m \u001b[0mlen\u001b[0m         \u001b[0;31m# 將 'len in foo' 刪除綁定\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      9\u001b[0m     \u001b[0mbar\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 10\u001b[0;31m     \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     11\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     12\u001b[0m \u001b[0mfoo\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mUnboundLocalError\u001b[0m: local variable 'len' referenced before assignment"
     ]
    }
   ],
   "source": [
    "len = \"global len\"\n",
    "def foo():\n",
    "    len = \"len in foo\"   # nonlocal 的 len\n",
    "    def bar():\n",
    "        nonlocal len\n",
    "        print(len)\n",
    "        len = \"len in bar\"\n",
    "        del len         # 將 'len in foo' 刪除綁定\n",
    "    bar()\n",
    "    print(len)\n",
    "    \n",
    "foo()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## A more complicated example\n",
    "\n",
    "#### closure ( 閉包 )\n",
    "\n",
    "```\n",
    "   =====================  ### namespace ###  ============================\n",
    "   built-in namespace \n",
    "   |\n",
    "   └──Global namespace  (def foo(n):)\n",
    "   =====================  ### enclosed(E) namespace  ###   ============================\n",
    "       | ( foo0 = foo(0) )          |  ( foo100 = foo(100) )\n",
    "       └── E namespace1 (val = 0)   └── E namespace2 (val = 100)\n",
    "   =====================  ### local(L) namespace  ###   ============================    \n",
    "       (def bar(x):)-------------------------|\n",
    "               |                             |                      ( nonlocal val )\n",
    "               └── L namespace1 (val += x)   └── L namespace2 (val += x)\n",
    "   =====================  ### each environment ###  ============================\n",
    "                   ∆                                         ∆\n",
    "                   |                                         |\n",
    "                   └── environment1                          └── environment2       \n",
    "\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def foo(n):\n",
    "    val = n\n",
    "    def bar(x):\n",
    "        nonlocal val\n",
    "        val += x\n",
    "        return val\n",
    "    return bar\n",
    "\n",
    "foo0 = foo(0)\n",
    "foo100 = foo(100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "150\n"
     ]
    }
   ],
   "source": [
    "print(foo0(4))\n",
    "print(foo100(50))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n",
      "155\n"
     ]
    }
   ],
   "source": [
    "print(foo0(5))\n",
    "print(foo100(5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lambda\n",
    "\n",
    "製作簡單的沒名稱的 function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "'''\n",
    "equal \n",
    "def a(x, y=1):\n",
    "    return (x*y) ** 5\n",
    "'''\n",
    "a = lambda x, y=1: (x*y) ** 5       "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "243"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7776"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a(3, 2)         #6 ** 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(lambda x,y:x*y)(2,5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# late binding\n",
    "\n",
    "def 只有定義函數而已，要到實際執行才會真正綁定變數"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def foo():\n",
    "    result = []\n",
    "    for i in range(3):\n",
    "        def bar(x):             #只有定義\n",
    "            return i*x             \n",
    "        result.append(bar)\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[<function foo.<locals>.bar at 0x1047440d0>, <function foo.<locals>.bar at 0x104744158>, <function foo.<locals>.bar at 0x1047441e0>]\n"
     ]
    }
   ],
   "source": [
    "a = foo()\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "10\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "for i in a:\n",
    "    print(i(5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# generator\n",
    "\n",
    "* yield\n",
    "* yield from\n",
    "* generator expression\n",
    "\n",
    "example\n",
    "* python3.x range\n",
    "* python2.x xrange\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<generator object <genexpr> at 0x104732780>"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = (i for i in [1,2,3,4,5,7,21,3,643,7e5,43,3] if i > 5)  #generator expression\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n",
      "21\n",
      "643\n",
      "700000.0\n",
      "43\n"
     ]
    }
   ],
   "source": [
    "for i in a:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<generator object foo at 0x104798bf8>"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def foo(n):\n",
    "    while True:\n",
    "        yield n\n",
    "        n+=1\n",
    "a = foo(5)\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "10\n",
      "11\n",
      "12\n",
      "13\n",
      "14\n"
     ]
    }
   ],
   "source": [
    "for i in range(10):\n",
    "    print(next(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15\n",
      "16\n",
      "17\n",
      "18\n",
      "19\n",
      "20\n",
      "21\n",
      "22\n",
      "23\n",
      "24\n",
      "25\n",
      "26\n",
      "27\n",
      "28\n",
      "29\n",
      "30\n"
     ]
    }
   ],
   "source": [
    "for i in a:\n",
    "    if i > 30:\n",
    "        break\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<generator object foo at 0x104732990>"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def foo():\n",
    "    print(\"first range\")\n",
    "    yield from range(10)\n",
    "    print(\"second range\")\n",
    "    yield from range(2)\n",
    "    print(\"third range\")\n",
    "    yield from range(5)\n",
    "a = foo()\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "first range\n",
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "second range\n",
      "0\n",
      "1\n",
      "third range\n",
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "for i in a:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 0 0\n",
      "0 0 1\n",
      "0 0 2\n",
      "0 0 3\n",
      "0 0 4\n",
      "0 0 5\n",
      "0 0 6\n",
      "0 0 7\n",
      "0 0 8\n",
      "0 0 9\n",
      "0 1 0\n",
      "0 1 1\n",
      "0 1 2\n",
      "0 1 3\n",
      "0 1 4\n",
      "0 1 5\n",
      "0 1 6\n",
      "0 1 7\n",
      "0 1 8\n",
      "0 1 9\n",
      "0 2 0\n",
      "0 2 1\n",
      "0 2 2\n",
      "0 2 3\n",
      "0 2 4\n",
      "0 2 5\n",
      "0 2 6\n",
      "0 2 7\n",
      "0 2 8\n",
      "0 2 9\n",
      "0 3 0\n",
      "0 3 1\n",
      "0 3 2\n",
      "0 3 3\n",
      "0 3 4\n",
      "0 3 5\n",
      "0 3 6\n",
      "0 3 7\n",
      "0 3 8\n",
      "0 3 9\n",
      "0 4 0\n",
      "0 4 1\n",
      "0 4 2\n",
      "0 4 3\n",
      "0 4 4\n",
      "0 4 5\n",
      "0 4 6\n",
      "0 4 7\n",
      "0 4 8\n",
      "0 4 9\n",
      "0 5 0\n",
      "0 5 1\n",
      "0 5 2\n",
      "0 5 3\n",
      "0 5 4\n",
      "0 5 5\n",
      "0 5 6\n",
      "0 5 7\n",
      "0 5 8\n",
      "0 5 9\n",
      "0 6 0\n",
      "0 6 1\n",
      "0 6 2\n",
      "0 6 3\n",
      "0 6 4\n",
      "0 6 5\n",
      "0 6 6\n",
      "0 6 7\n",
      "0 6 8\n",
      "0 6 9\n",
      "0 7 0\n",
      "0 7 1\n",
      "0 7 2\n",
      "0 7 3\n",
      "0 7 4\n",
      "0 7 5\n",
      "0 7 6\n",
      "0 7 7\n",
      "0 7 8\n",
      "0 7 9\n",
      "0 8 0\n",
      "0 8 1\n",
      "0 8 2\n",
      "0 8 3\n",
      "0 8 4\n",
      "0 8 5\n",
      "0 8 6\n",
      "0 8 7\n",
      "0 8 8\n",
      "0 8 9\n",
      "0 9 0\n",
      "0 9 1\n",
      "0 9 2\n",
      "0 9 3\n",
      "0 9 4\n",
      "0 9 5\n",
      "0 9 6\n",
      "0 9 7\n",
      "0 9 8\n",
      "0 9 9\n",
      "1 0 0\n",
      "1 0 1\n",
      "1 0 2\n",
      "1 0 3\n",
      "1 0 4\n",
      "1 0 5\n",
      "1 0 6\n",
      "1 0 7\n",
      "1 0 8\n",
      "1 0 9\n",
      "find answer\n"
     ]
    }
   ],
   "source": [
    "answer = (1, 0 ,9)\n",
    "def find_answer():\n",
    "    for i in range(10):\n",
    "        for j in range(10):\n",
    "            for k in range(10):\n",
    "                yield (i,j,k)\n",
    "\n",
    "                \n",
    "for i,j,k in find_answer():\n",
    "    print(i,j,k)\n",
    "    if (i,j,k) == answer:\n",
    "        print(\"find answer\")\n",
    "        break\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Decorator\n",
    "\n",
    "修飾 function 用\n",
    "\n",
    "語法\n",
    "``` \n",
    "    @decorator(args)\n",
    "    def f(...):\n",
    "        ...\n",
    "        \n",
    "    ||\n",
    "    \n",
    "    def f(...):\n",
    "        ...\n",
    "    f = decorator(args)(f)\n",
    "```        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from functools import wraps\n",
    "def add_5(func):\n",
    "    print(\"in add_5\")\n",
    "    @wraps(func)\n",
    "    def wrapper(n):\n",
    "        print(\"in wrapper\")\n",
    "        return func(n)+5\n",
    "    return wrapper"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "in add_5\n"
     ]
    }
   ],
   "source": [
    "@add_5\n",
    "def foo(n):\n",
    "    print(\"in foo\")\n",
    "    if n==0:\n",
    "        return 1\n",
    "    return 1 + foo(n-1)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "foo\n",
      "in wrapper\n",
      "in foo\n",
      "in wrapper\n",
      "in foo\n",
      "in wrapper\n",
      "in foo\n",
      "in wrapper\n",
      "in foo\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "24"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(foo.__name__)\n",
    "foo(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "in add_5\n",
      "in add_5\n"
     ]
    }
   ],
   "source": [
    "@add_5\n",
    "@add_5\n",
    "def foo(n):\n",
    "    print(\"in foo\")\n",
    "    if n==0:\n",
    "        return 1\n",
    "    return 1 + foo(n-1)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "in wrapper\n",
      "in wrapper\n",
      "in foo\n",
      "in wrapper\n",
      "in wrapper\n",
      "in foo\n",
      "in wrapper\n",
      "in wrapper\n",
      "in foo\n",
      "in wrapper\n",
      "in wrapper\n",
      "in foo\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "44"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "foo(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class Car:\n",
    "    def __init__(self, name, price, num):\n",
    "        self.name = name\n",
    "        self.price = price\n",
    "        self.num = num\n",
    "    def sell(self, n):\n",
    "        if n <= self.num:\n",
    "            print(\"sells for {} dollars.\".format(self.price * n))\n",
    "            self.num -= n\n",
    "        else:\n",
    "            print(\"Sorry, not enough item {}.\".format(self.name))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "car1 = Car(\"Car1\",20, 10 )\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Car1'"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "car1.name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sells for 140 dollars.\n"
     ]
    }
   ],
   "source": [
    "car1.sell(7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "car1.num"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class SportCar(Car):\n",
    "    def __init__(self, name , price, num , speed, tax):\n",
    "        super().__init__(name, price, num)\n",
    "        self.speed = speed\n",
    "        self.tax = tax\n",
    "    def feature(self):\n",
    "        print(\"this Car can run as {} km/h\".format(self.speed))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "myscar = SportCar(\"scar\", 1000, 3, 100, 1.7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'scar'"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myscar.name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "this Car can run as 100 km/h\n"
     ]
    }
   ],
   "source": [
    "myscar.feature()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sells for 2000 dollars.\n"
     ]
    }
   ],
   "source": [
    "myscar.sell(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myscar.num"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## decorator class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "35"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class foo:\n",
    "    def __init__(self, f):\n",
    "        self.f = f\n",
    "    def __call__(self, x,y,z):\n",
    "        return (x+y)*self.f(z)\n",
    "\n",
    "@foo\n",
    "def a (n):\n",
    "    return n\n",
    "\n",
    "a(3,4,5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "__main__.foo"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class foo:\n",
    "    def __init__(self, *args):\n",
    "        print(\"init foo\")\n",
    "        self.args = args\n",
    "    \n",
    "    def __call__(self, f):\n",
    "        print(\"calling foo\")\n",
    "        def wrapper(n):\n",
    "            print(\"inside wrapper\")\n",
    "            return sum(self.args)*f(n)\n",
    "        return wrapper\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "init foo\n",
      "calling foo\n"
     ]
    }
   ],
   "source": [
    "@foo(3,4,5)\n",
    "def fib(n):\n",
    "    print(\"inside fib {}\".format(n))\n",
    "    if n == 0 or n == 1:\n",
    "        return 1\n",
    "    else:\n",
    "        return fib(n-1) + fib(n-2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "inside wrapper\n",
      "inside fib 0\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "12"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fib(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "inside wrapper\n",
      "inside fib 3\n",
      "inside wrapper\n",
      "inside fib 2\n",
      "inside wrapper\n",
      "inside fib 1\n",
      "inside wrapper\n",
      "inside fib 0\n",
      "inside wrapper\n",
      "inside fib 1\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "3600"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fib(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# enumerate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 a\n",
      "1 b\n",
      "2 c\n"
     ]
    }
   ],
   "source": [
    "l = [\"a\", \"b\", \"c\"]\n",
    "for i,j in enumerate(l):\n",
    "    print(i,j)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(0, 1)\n",
      "a\n",
      "(1, 2)\n",
      "b\n",
      "(2, 3)\n",
      "c\n"
     ]
    }
   ],
   "source": [
    "a = {1:'a', 2:'b', 3:'c'}\n",
    "for i in enumerate(a):\n",
    "    print(i)\n",
    "    print(a[i[1]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# zip"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 'a')\n",
      "(2, 'b')\n",
      "(3, 'c')\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{1: 'a', 2: 'b', 3: 'c'}"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = (1,2,3)\n",
    "b = ['a', 'b', 'c']\n",
    "for i in zip(a,b):\n",
    "    print(i)\n",
    "    \n",
    "d = dict(zip(a,b))\n",
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 總複習\n",
    "\n",
    "* Scope \n",
    "    - namespace & environment\n",
    "    - del\n",
    "    - global\n",
    "    - nonlocal\n",
    "* Lambda\n",
    "* late binding\n",
    "* generator\n",
    "    - yield\n",
    "    - yield from\n",
    "    - generator expression\n",
    "* decorator\n",
    "* Class\n",
    "* decorator class\n",
    "* enumerate\n",
    "* zip"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 其他還有很多還沒包含的議題 (未全部列出)\n",
    "\n",
    "## 更多 Features\n",
    "\n",
    "* metaclass\n",
    "* Duck Typing\n",
    "* is v.s. ==\n",
    "* map\n",
    "* filter\n",
    "* reduce\n",
    "* partial\n",
    "* sum\n",
    "* First-class function\n",
    "* join\n",
    "* async, await\n",
    "* unit testing\n",
    "* built-in module\n",
    "\n",
    "## venv - Python3 內建的virtual environment module\n",
    "\n",
    "優點\n",
    "* 方便管理套件\n",
    "* 維持工作環境\n",
    "* 不需要 sudo 權限就能安裝套件\n",
    "\n",
    "創建 virtual environment ~\n",
    "\n",
    "```sh\n",
    "$ python -m \"venv\" PATH/TO/MY/Virtual/Environment\n",
    "```\n",
    "\n",
    "啟動 :\n",
    "\n",
    "```sh\n",
    "$ source PATH/TO/MY/Virtual/Environment/bin/activate #根據使用的 shell 來決定\n",
    "```\n",
    "\n",
    "## 利用 Python 做簡單的 http server\n",
    "\n",
    "\n",
    "```sh\n",
    "$ python -m http.server 8000\n",
    "```\n",
    "\n",
    "## Python3.6 release !!\n",
    "\n",
    "https://docs.python.org/3.6/whatsnew/3.6.html\n",
    "\n",
    "## Python3.6 官方文件\n",
    "\n",
    "https://docs.python.org/3.6/\n",
    "\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.5.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}