02_23notebook.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a=[1,2,3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "b=a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a.append(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 10]"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 10]"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a=a+[3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 10, 3]"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 10]"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def f(ls):\n",
    "    return [[x for x in range(y)] for y in ls]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[0], [0, 1], [0, 1, 2], [0, 1, 2, 3], [0, 1, 2, 3, 4]]"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f([1,2,3,4,5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def tree(label,branches=[]):\n",
    "    return [label]+list(branches)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def label(tree):\n",
    "    return tree[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def branches(tree):\n",
    "    return tree[1:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def print_tree(t,indent=0):\n",
    "    print('  '*indent+str(label(t)))\n",
    "    for b in branches(t):\n",
    "        print_tree(b,indent+1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "  2\n",
      "  3\n"
     ]
    }
   ],
   "source": [
    "print_tree(tree(1,[tree(2),tree(3)]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "t=tree(9,[tree(2),tree(4,[tree(1)]),tree(4,[tree(7),tree(3)])])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n",
      "  2\n",
      "  4\n",
      "    1\n",
      "  4\n",
      "    7\n",
      "    3\n"
     ]
    }
   ],
   "source": [
    "print_tree(tree(9,[tree(2),tree(4,[tree(1)]),tree(4,[tree(7),tree(3)])]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[4, [7], [3]]"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "branches(t)[2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "label(branches(t)[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def sum_of_nodes(t):\n",
    "    return sum([label(t)]+[sum_of_nodes(b) for b in branches(t)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "30"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum_of_nodes(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def memory(n):\n",
    "    def h(func):\n",
    "        nonlocal n\n",
    "        n=func(n)\n",
    "        print(n)\n",
    "        return h\n",
    "    return h"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "f=memory(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20\n"
     ]
    }
   ],
   "source": [
    "f = f(lambda x:x*2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "13\n"
     ]
    }
   ],
   "source": [
    "f = f(lambda x:x-7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "f = f(lambda x:x>5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a=[1,2,3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a.insert(1,8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 8, 2, 3]"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a.remove(8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3]"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.pop(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a.append([5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a.extend([5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3, [5], 5]"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def add_this_many(x,el,lst):\n",
    "    lst.extend([el for i in range(x)])\n",
    "    return lst"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "lst=[1,2,4,2,1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 4, 2, 1, 5]"
      ]
     },
     "execution_count": 125,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "add_this_many(1,5,lst)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 4, 2, 1, 5, 2, 2]"
      ]
     },
     "execution_count": 126,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "add_this_many(2,2,lst)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[5, [5], 3, 1]"
      ]
     },
     "execution_count": 128,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[::-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def reverse(lst):\n",
    "    def change():\n",
    "        nonlocal lst\n",
    "        b=lst[::-1]\n",
    "        lst=b\n",
    "        return lst\n",
    "    return change()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x=[3,2,4,5,1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 5, 4, 2, 3]"
      ]
     },
     "execution_count": 146,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "reverse(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 2, 4, 5, 1]"
      ]
     },
     "execution_count": 147,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def reverse(lst):\n",
    "    for i in range(len(lst)//2):\n",
    "        lst[i],lst[-i-1] = lst[-i-1],lst[i]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a=[1,2,3,4,5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "reverse(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[5, 4, 3, 2, 1]"
      ]
     },
     "execution_count": 157,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "dic={'a':1,'b':2}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 161,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'a' in dic"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "dic['c']=6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': 1, 'b': 2, 'c': 6}"
      ]
     },
     "execution_count": 163,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dic"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 164,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(dic)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "dic[('e','f')]=5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 169,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "dic[1]=4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def group_by(s,fn):\n",
    "    new=[]\n",
    "    for x in s:\n",
    "        if fn(x) not in new:\n",
    "            new.append(fn(x))\n",
    "    newl=[[] for _ in new]\n",
    "    for i,f in enumerate(new):\n",
    "        for x in s:\n",
    "            if fn(x)==f:\n",
    "                newl[i].append(x)\n",
    "    dic={}\n",
    "    for f,l in zip(new,newl):\n",
    "        dic[f]=l\n",
    "    return dic"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 175,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1: [12, 14], 2: [23], 4: [45]}"
      ]
     },
     "execution_count": 175,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "group_by([12,23,14,45],lambda p:p//10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 176,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0: [0], 1: [-1, 1], 4: [-2, 2], 9: [-3, 3]}"
      ]
     },
     "execution_count": 176,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "group_by(range(-3, 4), lambda x: x * x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#简便的做法\n",
    "def group_by(s,fn):\n",
    "    grouped={}\n",
    "    for x in s:\n",
    "        key=fn(x)\n",
    "        if key in grouped:\n",
    "            grouped[key].append(x)\n",
    "        else:\n",
    "            grouped[key]=[x]\n",
    "    return grouped"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 177,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def replace_all_deep(d,x,y):\n",
    "    for key,value in d.items():\n",
    "        if type(value)!=dict:\n",
    "            if value==x:\n",
    "                d[key]=y\n",
    "        else:\n",
    "            replace_all_deep(value,x,y)\n",
    "    return d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 184,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    " d = {1: {2: 'x', 'x': 4}, 2: {4: 4, 5: 'x'}}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 185,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1: {2: 'y', 'x': 4}, 2: {4: 4, 5: 'y'}}"
      ]
     },
     "execution_count": 185,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    " replace_all_deep(d, 'x', 'y')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 183,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#简便的做法\n",
    "def replace_all_deep(d,x,y):\n",
    "    for key in d:\n",
    "        if d[key]==x:\n",
    "            d[key]=y\n",
    "        elif type(d[key]) == dict:\n",
    "            replace_all_deep(d[key],x,y)\n",
    "    return d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 190,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def f(t):\n",
    "    if label(t)==1:\n",
    "        return 1\n",
    "    return t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 189,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 189,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "label(tree(1))==1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 193,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def replace_leaf(t, old, new):\n",
    "    \"\"\"Returns a new tree where every leaf value equal to old has\n",
    "    been replaced with new.\n",
    "\n",
    "    >>> yggdrasil = tree('odin',\n",
    "    ...                  [tree('balder',\n",
    "    ...                        [tree('thor'),\n",
    "    ...                         tree('loki')]),\n",
    "    ...                   tree('frigg',\n",
    "    ...                        [tree('thor')]),\n",
    "    ...                   tree('thor',\n",
    "    ...                        [tree('sif'),\n",
    "    ...                         tree('thor')]),\n",
    "    ...                   tree('thor')])\n",
    "    >>> laerad = copy_tree(yggdrasil) # copy yggdrasil for testing purposes\n",
    "    >>> print_tree(replace_leaf(yggdrasil, 'thor', 'freya'))\n",
    "    odin\n",
    "      balder\n",
    "        freya\n",
    "        loki\n",
    "      frigg\n",
    "        freya\n",
    "      thor\n",
    "        sif\n",
    "        freya\n",
    "      freya\n",
    "    >>> laerad == yggdrasil # Make sure original tree is unmodified\n",
    "    True\n",
    "    \"\"\"\n",
    "    if label(t)==old:\n",
    "        lab=new\n",
    "    else:\n",
    "        lab=label(t)\n",
    "    return tree(lab,[replace_leaf(b, old, new) for b in branches(t)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 221,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def print_move(origin, destination):\n",
    "    \"\"\"Print instructions to move a disk.\"\"\"\n",
    "    print(\"Move the top disk from rod\", origin, \"to rod\", destination)\n",
    "\n",
    "def move_stack(n, start, end):\n",
    "    \"\"\"Print the moves required to move n disks on the start pole to the end\n",
    "    pole without violating the rules of Towers of Hanoi.\n",
    "\n",
    "    n -- number of disks\n",
    "    start -- a pole position, either 1, 2, or 3\n",
    "    end -- a pole position, either 1, 2, or 3\n",
    "\n",
    "    There are exactly three poles, and start and end must be different. Assume\n",
    "    that the start pole has at least n disks of increasing size, and the end\n",
    "    pole is either empty or has a top disk larger than the top n start disks.\n",
    "\n",
    "    >>> move_stack(1, 1, 3)\n",
    "    Move the top disk from rod 1 to rod 3\n",
    "    >>> move_stack(2, 1, 3)\n",
    "    Move the top disk from rod 1 to rod 2\n",
    "    Move the top disk from rod 1 to rod 3\n",
    "    Move the top disk from rod 2 to rod 3\n",
    "    >>> move_stack(3, 1, 3)\n",
    "    Move the top disk from rod 1 to rod 3\n",
    "    Move the top disk from rod 1 to rod 2\n",
    "    Move the top disk from rod 3 to rod 2\n",
    "    Move the top disk from rod 1 to rod 3\n",
    "    Move the top disk from rod 2 to rod 1\n",
    "    Move the top disk from rod 2 to rod 3\n",
    "    Move the top disk from rod 1 to rod 3\n",
    "    \"\"\"\n",
    "    assert 1 <= start <= 3 and 1 <= end <= 3 and start != end, \"Bad start/end\"\n",
    "    a=[start,end]\n",
    "    for i in range(1,4):\n",
    "        if i not in a:\n",
    "            middle=i\n",
    "    if n==1:\n",
    "        print_move(start,end)\n",
    "    elif n==2:\n",
    "        print_move(start,middle)\n",
    "        print_move(start,end)\n",
    "        print_move(middle,end)\n",
    "    else:\n",
    "        move_stack(n-1,start,middle)\n",
    "        print_move(start,end)\n",
    "        move_stack(n-1,middle,end)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 222,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Move the top disk from rod 1 to rod 3\n"
     ]
    }
   ],
   "source": [
    "move_stack(1, 1, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 223,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Move the top disk from rod 1 to rod 2\n",
      "Move the top disk from rod 1 to rod 3\n",
      "Move the top disk from rod 2 to rod 3\n"
     ]
    }
   ],
   "source": [
    "move_stack(2, 1, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 224,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Move the top disk from rod 1 to rod 3\n",
      "Move the top disk from rod 1 to rod 2\n",
      "Move the top disk from rod 3 to rod 2\n",
      "Move the top disk from rod 1 to rod 3\n",
      "Move the top disk from rod 2 to rod 1\n",
      "Move the top disk from rod 2 to rod 3\n",
      "Move the top disk from rod 1 to rod 3\n"
     ]
    }
   ],
   "source": [
    "move_stack(3, 1, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 228,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def is_tree(tree):\n",
    "    \"\"\"Returns True if the given tree is a tree, and False otherwise.\"\"\"\n",
    "    if type(tree) != list or len(tree) < 1:\n",
    "        return False\n",
    "    for branch in branches(tree):\n",
    "        if not is_tree(branch):\n",
    "            return False\n",
    "    return True\n",
    "\n",
    "def is_leaf(tree):\n",
    "    \"\"\"Returns True if the given tree's list of branches is empty, and False\n",
    "    otherwise.\n",
    "    \"\"\"\n",
    "    return not branches(tree)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 232,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def mobile(left, right):\n",
    "    \"\"\"Construct a mobile from a left side and a right side.\"\"\"\n",
    "    return tree('mobile', [left, right])\n",
    "\n",
    "def is_mobile(m):\n",
    "    return is_tree(m) and label(m) == 'mobile'\n",
    "\n",
    "def sides(m):\n",
    "    \"\"\"Select the sides of a mobile.\"\"\"\n",
    "    assert is_mobile(m), \"must call sides on a mobile\"\n",
    "    return branches(m)\n",
    "\n",
    "def is_side(m):\n",
    "    return not is_mobile(m) and not is_weight(m) and type(label(m)) == int\n",
    "\n",
    "def side(length, mobile_or_weight):\n",
    "    \"\"\"Construct a side: a length of rod with a mobile or weight at the end.\"\"\"\n",
    "    return tree(length, [mobile_or_weight])\n",
    "\n",
    "def length(s):\n",
    "    \"\"\"Select the length of a side.\"\"\"\n",
    "    assert is_side(s), \"must call length on a side\"\n",
    "    return label(s)\n",
    "\n",
    "def end(s):\n",
    "    \"\"\"Select the mobile or weight hanging at the end of a side.\"\"\"\n",
    "    assert is_side(s), \"must call end on a side\"\n",
    "    return branches(s)[0]\n",
    "\n",
    "def weight(size):\n",
    "    \"\"\"Construct a weight of some size.\"\"\"\n",
    "    assert size > 0\n",
    "    return [size]\n",
    "\n",
    "def size(w):\n",
    "    \"\"\"Select the size of a weight.\"\"\"\n",
    "    return w[0]\n",
    "\n",
    "def is_weight(w):\n",
    "    \"\"\"Whether w is a weight, not a mobile.\"\"\"\n",
    "    return not is_mobile(w) and len(w)==1\n",
    "\n",
    "def examples():\n",
    "    t = mobile(side(1, weight(2)),\n",
    "               side(2, weight(1)))\n",
    "    u = mobile(side(5, weight(1)),\n",
    "               side(1, mobile(side(2, weight(3)),\n",
    "                              side(3, weight(2)))))\n",
    "    v = mobile(side(4, t), side(2, u))\n",
    "    return (t, u, v)\n",
    "\n",
    "\n",
    "def total_weight(m):\n",
    "    \"\"\"Return the total weight of m, a weight or mobile.\n",
    "\n",
    "    >>> t, u, v = examples()\n",
    "    >>> total_weight(t)\n",
    "    3\n",
    "    >>> total_weight(u)\n",
    "    6\n",
    "    >>> total_weight(v)\n",
    "    9\n",
    "    \"\"\"\n",
    "    if is_weight(m):\n",
    "        return size(m)\n",
    "    else:\n",
    "        assert is_mobile(m), \"must get total weight of a mobile or a weight\"\n",
    "        return sum([total_weight(end(s)) for s in sides(m)])\n",
    "\n",
    "def balanced(m):\n",
    "    \"\"\"Return whether m is balanced.\n",
    "\n",
    "    >>> t, u, v = examples()\n",
    "    >>> balanced(t)\n",
    "    True\n",
    "    >>> balanced(v)\n",
    "    True\n",
    "    >>> w = mobile(side(3, t), side(2, u))\n",
    "    >>> balanced(w)\n",
    "    False\n",
    "    >>> balanced(mobile(side(1, v), side(1, w)))\n",
    "    False\n",
    "    >>> balanced(mobile(side(1, w), side(1, v)))\n",
    "    False\n",
    "    \"\"\"\n",
    "    assert is_mobile(m), \"must be a mobile\"\n",
    "    left=sides(m)[0]\n",
    "    right=sides(m)[1]\n",
    "    a=end(left)\n",
    "    b=end(right)\n",
    "    if length(left)*total_weight(a)==length(right)*total_weight(b):\n",
    "        if is_mobile(a) and is_mobile(b):\n",
    "            return balanced(a) and balanced(b)\n",
    "        elif is_mobile(a):\n",
    "            return balanced(a)\n",
    "        elif is_mobile(b):\n",
    "            return balanced(b)\n",
    "        return True\n",
    "    return False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 233,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "t, u, v = examples()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 234,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 234,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "balanced(t)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Objects"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 263,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class Account:\n",
    "    interest=0.02\n",
    "    def __init__(self, account_holder):\n",
    "        self.balance=0\n",
    "        self.holder=account_holder\n",
    "        \n",
    "    def deposit(self,amount):\n",
    "        self.balance=self.balance+amount\n",
    "        return self.balance\n",
    "    \n",
    "    def withdraw(self,amount):\n",
    "        if self.balance<amount:\n",
    "            return \"Insufficient Funds\"\n",
    "        self.balance=self.balance-amount\n",
    "        return self.balance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 265,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a=Account('Amy')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 247,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 247,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.balance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 248,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 248,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.deposit(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 249,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 249,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.withdraw(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 250,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Insufficient Funds'"
      ]
     },
     "execution_count": 250,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.withdraw(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 251,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "__main__.Account"
      ]
     },
     "execution_count": 251,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Account"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 252,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<__main__.Account at 0x2bf35b62b38>"
      ]
     },
     "execution_count": 252,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 253,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "__main__.Account"
      ]
     },
     "execution_count": 253,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 254,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 254,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(a.balance)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 255,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<function getattr>"
      ]
     },
     "execution_count": 255,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "getattr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 257,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 257,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "getattr(a,'balance')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 258,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 258,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hasattr(a,'balance')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 259,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 259,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hasattr(a,'deposit')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 261,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "function"
      ]
     },
     "execution_count": 261,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(Account.deposit)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 262,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "method"
      ]
     },
     "execution_count": 262,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(a.deposit)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 266,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.02"
      ]
     },
     "execution_count": 266,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.interest"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 267,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.02"
      ]
     },
     "execution_count": 267,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Account.interest"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 290,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "Account.interest=0.1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 291,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.1"
      ]
     },
     "execution_count": 291,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Account.interest"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 293,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a.interest=0.2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 295,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.2"
      ]
     },
     "execution_count": 295,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.interest"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 296,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.1"
      ]
     },
     "execution_count": 296,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Account.interest"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 297,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class CheckingAccount(Account):\n",
    "    interest=0.01\n",
    "    withdraw_fee=1\n",
    "    def withdraw(self,amount):\n",
    "        return Account.withdraw(self, amount+self.withdraw_fee)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 298,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "ch=CheckingAccount('Tom') #Calls Account.__init__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 299,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.01"
      ]
     },
     "execution_count": 299,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ch.interest #Found in CheckingAccount"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 300,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20"
      ]
     },
     "execution_count": 300,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ch.deposit(20) #Found in Account"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 301,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "14"
      ]
     },
     "execution_count": 301,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ch.withdraw(5) #Found in CheckingAccount"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 303,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class Bank:\n",
    "    def __init__(self):\n",
    "        self.accounts=[]\n",
    "    def open_account(self,holder,amount,kind=Account):\n",
    "        account=kind(holder)\n",
    "        account.deposit(amount)\n",
    "        self.accounts.append(account)\n",
    "        return account\n",
    "    def pay_interest(self):\n",
    "        for a in self.accounts:\n",
    "            a.deposit(a.balance*a.interest)\n",
    "    def too_big_to_fail(self):\n",
    "        return len(self.accounts)>1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 304,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "bank=Bank()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 305,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "john=bank.open_account('John',10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 306,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "jack=bank.open_account('Jack',5,CheckingAccount)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 307,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.1"
      ]
     },
     "execution_count": 307,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "john.interest"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 308,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.01"
      ]
     },
     "execution_count": 308,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "jack.interest"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 309,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "bank.pay_interest()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 310,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11.0"
      ]
     },
     "execution_count": 310,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "john.balance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 311,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 311,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bank.too_big_to_fail()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 316,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class A:\n",
    "    z=-1\n",
    "    def f(self,x):\n",
    "        return B(x-1)\n",
    "class B(A):\n",
    "    n=4\n",
    "    def __init__(self,y):\n",
    "        if y:\n",
    "            self.z = self.f(y)\n",
    "        else:\n",
    "            self.z = C(y+1)\n",
    "class C(B):\n",
    "    def f(self,x):\n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 317,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a=A()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 318,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<__main__.A at 0x2bf3fb44ba8>"
      ]
     },
     "execution_count": 318,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 319,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "b=B(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 325,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<__main__.B at 0x2bf3fb44ef0>"
      ]
     },
     "execution_count": 325,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b.z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 326,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "b.n=5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 327,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 327,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b.n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 328,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 328,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "C(2).n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 329,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1"
      ]
     },
     "execution_count": 329,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 330,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1"
      ]
     },
     "execution_count": 330,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "C.z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 331,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<__main__.B at 0x2bf3fb44ef0>"
      ]
     },
     "execution_count": 331,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b.z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 332,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<__main__.C at 0x2bf3fb44f98>"
      ]
     },
     "execution_count": 332,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b.z.z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 336,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<__main__.B at 0x2bf3fb44e80>"
      ]
     },
     "execution_count": 336,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 337,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<__main__.B at 0x2bf3fb44ef0>"
      ]
     },
     "execution_count": 337,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b.z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 338,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<__main__.C at 0x2bf3fb44f98>"
      ]
     },
     "execution_count": 338,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b.z.z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 339,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 339,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b.z.z.z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 340,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class SavingsAccount(Account):\n",
    "    deposit_fee=2\n",
    "    def deposit(self,amount):\n",
    "        return Account.deposit(self,amount-self.deposit_fee)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 342,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class AsSeenOnTVAccount(CheckingAccount,SavingsAccount): #括号里面是base classes\n",
    "    def __init__(self,account_holder):\n",
    "        self.holder=account_holder\n",
    "        self.balance=1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 344,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "s=SavingsAccount('john')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 346,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 346,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.deposit(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 347,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 347,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.balance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 348,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 348,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.deposit_fee"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 349,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "g=AsSeenOnTVAccount('John')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 350,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'John'"
      ]
     },
     "execution_count": 350,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g.holder"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 351,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 351,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g.balance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 352,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 352,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g.deposit(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 353,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 353,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g.balance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 354,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 354,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g.withdraw(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 355,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 355,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g.balance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "totals={}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "totals.get('a',0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "totals={'a':4}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "totals.get('a',0)+1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def make_fib():\n",
    "    \"\"\"Returns a function that returns the next Fibonacci number\n",
    "    every time it is called.\n",
    "\n",
    "    >>> fib = make_fib()\n",
    "    >>> fib()\n",
    "    0\n",
    "    >>> fib()\n",
    "    1\n",
    "    >>> fib()\n",
    "    1\n",
    "    >>> fib()\n",
    "    2\n",
    "    >>> fib()\n",
    "    3\n",
    "    >>> fib2 = make_fib()\n",
    "    >>> fib() + sum([fib2() for _ in range(5)])\n",
    "    12\n",
    "    \"\"\"\n",
    "    num1=0\n",
    "    num2=1\n",
    "    times=0\n",
    "    def call():\n",
    "        nonlocal num1,num2,times\n",
    "        times+=1\n",
    "        if times==1:\n",
    "            return 0\n",
    "        if times==2:\n",
    "            return 1\n",
    "        else:\n",
    "            num1,num2 = num2,num1+num2\n",
    "            return num2\n",
    "    return call"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "fib=make_fib()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fib()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fib()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fib()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.581558809636278"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1/(1/(6.8*0.9)+1/(4.7*0.95))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'1 to 4'"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'{0} to {1}'.format(1, 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class Car(object):\n",
    "    num_wheels = 4\n",
    "    gas = 30\n",
    "    headlights = 2\n",
    "    size = 'Tiny'\n",
    "\n",
    "    def __init__(self, make, model):\n",
    "        self.make = make\n",
    "        self.model = model\n",
    "        self.color = 'No color yet. You need to paint me.'\n",
    "        self.wheels = Car.num_wheels\n",
    "        self.gas = Car.gas\n",
    "\n",
    "    def paint(self, color):\n",
    "        self.color = color\n",
    "        return self.make + ' ' + self.model + ' is now ' + color\n",
    "\n",
    "    def drive(self):\n",
    "        if self.wheels < Car.num_wheels or self.gas <= 0:\n",
    "            return self.make + ' ' + self.model + ' cannot drive!'\n",
    "        self.gas -= 10\n",
    "        return self.make + ' ' + self.model + ' goes vroom!'\n",
    "\n",
    "    def pop_tire(self):\n",
    "        if self.wheels > 0:\n",
    "            self.wheels -= 1\n",
    "\n",
    "    def fill_gas(self):\n",
    "        self.gas += 20\n",
    "        return self.make + ' ' + self.model + ' gas level: ' + str(self.gas)\n",
    "\n",
    "\n",
    "class MonsterTruck(Car):\n",
    "    size = 'Monster'\n",
    "\n",
    "    def rev(self):\n",
    "        print('Vroom! This Monster Truck is huge!')\n",
    "\n",
    "    def drive(self):\n",
    "        self.rev()\n",
    "        return Car.drive(self)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "truck = MonsterTruck('a','s9')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Vroom! This Monster Truck is huge!\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'a s9 goes vroom!'"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "truck.drive()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "location='gbc'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Can't go to gbc.\n"
     ]
    }
   ],
   "source": [
    "print(\"Can't go to \" + location +'.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}