12day.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "f7013a90",
   "metadata": {},
   "source": [
    "### 데코레이터"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "b2ce97f0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "함수를 시작합니다.\n",
      "함수를 종료합니다.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "16"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def make_func_alarm(func):\n",
    "    def new_func(*args, **kwargs):\n",
    "        print(\"함수를 시작합니다.\")\n",
    "        result = func(*args, **kwargs)\n",
    "        print('함수를 종료합니다.')\n",
    "        return result\n",
    "    return new_func\n",
    "\n",
    "def big_number(n):\n",
    "    return n ** n ** n\n",
    "\n",
    "new_func = make_func_alarm(big_number)\n",
    "new_func(2)\n",
    "\n",
    "# big_number(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "cd2b777f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "함수를 시작합니다.\n",
      "함수를 종료합니다.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "16"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def make_func_alarm(func):\n",
    "    def new_func(*args, **kwargs):\n",
    "        print(\"함수를 시작합니다.\")\n",
    "        result = func(*args, **kwargs)\n",
    "        print('함수를 종료합니다.')\n",
    "        return result\n",
    "    return new_func\n",
    "\n",
    "@make_func_alarm\n",
    "def big_number(n):\n",
    "      return n ** n ** n\n",
    "\n",
    "big_number(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "29ee9eb2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "실행시간: 0.00017849999994723476\n",
      "실행시간: 0.0008461999998417014\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "\n",
    "def foo(n):\n",
    "    for i in range(n):\n",
    "        pass\n",
    "  \n",
    "def bar(n):\n",
    "    if n==0:\n",
    "        return 0\n",
    "    return bar(n-1)\n",
    "\n",
    "start_time = time.perf_counter()\n",
    "foo(1000)\n",
    "end_time = time.perf_counter()\n",
    "print('실행시간:', end_time - start_time)\n",
    "\n",
    "start_time = time.perf_counter()\n",
    "bar(1000)\n",
    "end_time = time.perf_counter()\n",
    "print('실행시간:', end_time - start_time)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "35a97d92",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "실행시간: 1.8400000044493936e-05\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "\n",
    "def make_time_checker(func):\n",
    "    def new_func(*args, **kwargs):\n",
    "        start_time = time.perf_counter()\n",
    "        result = func(*args, **kwargs)\n",
    "        end_time = time.perf_counter()\n",
    "        print('실행시간:', end_time - start_time)\n",
    "        return result\n",
    "    \n",
    "    return new_func\n",
    "\n",
    "def foo(n):\n",
    "    for i in range(n):\n",
    "        pass\n",
    "\n",
    "func = make_time_checker(foo)\n",
    "func(1000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "3c74154a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "실행시간: 3.2699999792384915e-05\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import time\n",
    "\n",
    "def make_time_checker(func):\n",
    "    def new_func(*args, **kwargs):\n",
    "        start_time = time.perf_counter()\n",
    "        result = func(*args, **kwargs)\n",
    "        end_time = time.perf_counter()\n",
    "        print('실행시간:', end_time - start_time)\n",
    "        return result\n",
    "    \n",
    "    return new_func\n",
    "\n",
    "def bar(n):\n",
    "    if n==0:\n",
    "        return 0\n",
    "    return bar(n-1)\n",
    "\n",
    "func = make_time_checker(bar)\n",
    "func(100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "id": "2f2ed54d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "실행시간: 5.310000005920301e-05\n",
      "실행시간: 0.00041789999977481784\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import time\n",
    "\n",
    "def make_time_checker(func):\n",
    "    def new_func(*args, **kwargs):\n",
    "        start_time = time.perf_counter()\n",
    "        result = func(*args, **kwargs)\n",
    "        end_time = time.perf_counter()\n",
    "        print('실행시간:', end_time - start_time)\n",
    "        return result\n",
    "    \n",
    "    return new_func\n",
    "\n",
    "def foo(n):\n",
    "    for i in range(n):\n",
    "        pass\n",
    "\n",
    "def bar(n):\n",
    "    if n==0:\n",
    "        return 0\n",
    "    return bar(n-1)\n",
    "\n",
    "func = make_time_checker(foo)\n",
    "func(1000)\n",
    "\n",
    "func = make_time_checker(bar)\n",
    "func(1000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "id": "46669c11",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "실행시간: 6.000000212225132e-07\n",
      "실행시간: 0.00010820000034073018\n",
      "실행시간: 0.00015780000012455275\n",
      "실행시간: 0.00028949999978067353\n",
      "실행시간: 0.00031690000014350517\n",
      "실행시간: 0.0004791000001205248\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import time\n",
    "\n",
    "def make_time_checker(func):\n",
    "    def new_func(*args, **kwargs):\n",
    "        start_time = time.perf_counter()\n",
    "        result = func(*args, **kwargs)\n",
    "        end_time = time.perf_counter()\n",
    "        print('실행시간:', end_time - start_time)\n",
    "        return result\n",
    "    \n",
    "    return new_func\n",
    "\n",
    "# @make_time_checker\n",
    "# def foo(n):              # new_func(10)\n",
    "#     for i in range(n):\n",
    "#         pass\n",
    "\n",
    "\n",
    "def bar(n):              # new_func(10)\n",
    "    if n==0:\n",
    "        return 0\n",
    "    return new_func(n-1)      # new_func(9)\n",
    "\n",
    "def new_func(*args, **kwargs):\n",
    "    start_time = time.perf_counter()\n",
    "    result = bar(*args, **kwargs)\n",
    "    end_time = time.perf_counter()\n",
    "    print('실행시간:', end_time - start_time)\n",
    "    return result\n",
    "    \n",
    "new_func(5)\n",
    "\n",
    "\n",
    "# # foo(1000)\n",
    "# bar(5)\n",
    "\n",
    "# @make_time_checker\n",
    "# def bar(n):              # new_func(10)\n",
    "#     if n==0:\n",
    "#         return 0\n",
    "#     return bar(n-1)      # new_func(9)\n",
    "\n",
    "# # foo(1000)\n",
    "# bar(5)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1dbc3222",
   "metadata": {},
   "source": [
    "### 함수 로그 활용"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "id": "7adaf5e5",
   "metadata": {},
   "outputs": [],
   "source": [
    "enable_tracing = True\n",
    "   \n",
    "def trace(func):\n",
    "    if enable_tracing:\n",
    "        def callf(*args,**kwargs):\n",
    "            debug_log = open(\"debug.log\",\"a\")\n",
    "            debug_log.write(\"Calling %s: %s, %s\\n\"%\n",
    "                           (func.__name__,args,kwargs))\n",
    "            r = func(*args,**kwargs)\n",
    "            debug_log.write(\"%s returned %d\\n\"%\n",
    "                           (func.__name__,r))\n",
    "            debug_log.close()\n",
    "            return r\n",
    "        return callf\n",
    "    else :\n",
    "        return func"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "7c961877",
   "metadata": {},
   "outputs": [],
   "source": [
    "enable_tracing = True\n",
    "   \n",
    "def trace(func):\n",
    "    if enable_tracing:\n",
    "        def callf(*args,**kwargs):\n",
    "            with  open(\"debug.log\",\"a\") as debug_log :\n",
    "                debug_log.write(\"Calling %s: %s, %s\\n\"%\n",
    "                               (func.__name__,args,kwargs))\n",
    "                r = func(*args,**kwargs)\n",
    "                debug_log.write(\"%s returned %d\\n\"%\n",
    "                               (func.__name__,r))\n",
    "            return r\n",
    "        return callf\n",
    "    else :\n",
    "        return func"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "38c586ed",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10000"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@trace\n",
    "def square(x):\n",
    "    return x*x\n",
    "\n",
    "square(100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "8204aa60",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@trace\n",
    "def foo(a,b,c,d,e):\n",
    "    return a+b+c+d+e\n",
    "\n",
    "foo(1,2,3,4,5)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "186e8f79",
   "metadata": {},
   "source": [
    "### iterator(반복자)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "2676dc7d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "#root:x:0:0:root:/root:/bin/bash\n",
      "#daemon:x:1:1:daemon:/usr/sbin:/usr/sbin/nologin\n",
      "#bin:x:2:2:bin:/bin:/usr/sbin/nologin\n",
      "#sys:x:3:3:sys:/dev:/usr/sbin/nologin\n",
      "sync:x:4:65534:sync:/bin:/bin/sync"
     ]
    }
   ],
   "source": [
    "with open(\"passwd\") as f:\n",
    "    try:\n",
    "        while True:\n",
    "            line = next(f)\n",
    "            print(line, end='')\n",
    "    except StopIteration:\n",
    "        pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "31d37447",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'list'>\n",
      "<class 'list_iterator'>\n",
      "1\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "items = [1, 2, 3]\n",
    "print(type(items))\n",
    "it = iter(items)  # items.__iter__()\n",
    "print(type(it))\n",
    "print(next(it))\n",
    "print(next(it))\n",
    "print(next(it))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "be7c043a",
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    print(next(it))\n",
    "except StopIteration:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "5815ca0d",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "items = [1, 2, 3]\n",
    "it = iter(items)\n",
    "try:\n",
    "    while True:\n",
    "        print(next(it))\n",
    "except StopIteration:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "09bd316d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "items = [1, 2, 3]\n",
    "for x in items:\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "67ffe251",
   "metadata": {},
   "source": [
    "### 이터레이터를 지원하도록 구현"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "483f4f12",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Node:\n",
    "    def __init__(self, value):\n",
    "#         print( 'Node.__init__()')\n",
    "        self._value = value\n",
    "        self._children = []\n",
    "\n",
    "    def __repr__(self):\n",
    "        return 'Node({!r})'.format(self._value)\n",
    "\n",
    "    def add_child(self, node):\n",
    "        self._children.append(node)\n",
    "\n",
    "    def __iter__(self):\n",
    "        return iter(self._children)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "b05a21c6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Node(10)\n"
     ]
    }
   ],
   "source": [
    "node = Node(10)\n",
    "print(node)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "74639ae9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<list_iterator object at 0x000001F1AE5E2850>\n"
     ]
    }
   ],
   "source": [
    "i = iter(node)\n",
    "print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "e65c288d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Node(1)\n",
      "Node(2)\n"
     ]
    }
   ],
   "source": [
    "root = Node(0)\n",
    "child1 = Node(1)\n",
    "child2 = Node(2)\n",
    "root.add_child(child1)\n",
    "root.add_child(child2)\n",
    "\n",
    "# try:\n",
    "#     i = iter(root)\n",
    "#     print(next(i))\n",
    "#     print(next(i))\n",
    "#     print(next(i))\n",
    "# except StopIteration:\n",
    "#     pass \n",
    "\n",
    "# try:\n",
    "#     i = iter(root)\n",
    "#     while True:\n",
    "#         print(next(i))\n",
    "# except StopIteration:\n",
    "#     pass \n",
    "\n",
    "for ch in root:\n",
    "    print(ch)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c8671099",
   "metadata": {},
   "source": [
    "### generator(제너레이터)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "d6cec680",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'function'>\n",
      "1\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "def foo():\n",
    "    return 1\n",
    "    return 2\n",
    "\n",
    "print(type(foo))\n",
    "print(foo())\n",
    "print(foo())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "316c90f3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'function'>\n",
      "1\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "def foo():\n",
    "    yield 1\n",
    "    yield 2\n",
    "\n",
    "print(type(foo))\n",
    "g = foo()\n",
    "print(next(g))\n",
    "print(next(g))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "0a346972",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4]\n",
      "[5, 6, 7, 8]\n",
      "[9, 10, 11, 12]\n"
     ]
    }
   ],
   "source": [
    "def foo(size):\n",
    "    data = [1,2,3,4,5,6,7,8,9,10,11,12]\n",
    "    count = len(data)//size\n",
    "    for i in range(count):\n",
    "        yield data[i*size:(i+1)*size]\n",
    "\n",
    "g = foo(4)\n",
    "for x in g:\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "7c2470f1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 0.5 1.0 1.5 2.0 2.5 3.0 3.5 "
     ]
    }
   ],
   "source": [
    "def frange(start, stop, increment):\n",
    "    x = start\n",
    "    while x < stop:\n",
    "        yield x\n",
    "        x += increment\n",
    "\n",
    "for n in frange(0, 4, 0.5):\n",
    "    print(n , end=' ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "993ea552",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 0.125, 0.25, 0.375, 0.5, 0.625, 0.75, 0.875]"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(frange(0, 1, 0.125))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "6517d70d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 1 2 3 "
     ]
    }
   ],
   "source": [
    "def my_range(start, stop, increment):\n",
    "    x = start\n",
    "    while x < stop:\n",
    "        yield x\n",
    "        x += increment\n",
    "\n",
    "for n in my_range(0, 4, 1):\n",
    "    print(n , end=' ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "a75926ca",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Starting to count from 3\n",
      "3\n",
      "2\n",
      "1\n",
      "Done!\n"
     ]
    }
   ],
   "source": [
    "def countdown(n):\n",
    "    print('Starting to count from',n)\n",
    "    while n > 0:\n",
    "        yield n\n",
    "        n -= 1\n",
    "    print('Done!')\n",
    "    \n",
    "c = countdown(3)\n",
    "# print(next(c))\n",
    "# print(next(c))\n",
    "# print(next(c))\n",
    "for count in c:\n",
    "    print(count)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a4184eed",
   "metadata": {},
   "source": [
    "### 이터레이터 프로토콜의 구현"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "0244d4ce",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Node:\n",
    "    def __init__(self, value):\n",
    "        self._value = value\n",
    "        self._children = []\n",
    "\n",
    "    def __repr__(self):\n",
    "        return 'Node({!r})'.format(self._value)\n",
    "\n",
    "    def add_child(self, node):\n",
    "        self._children.append(node)\n",
    "\n",
    "    def __iter__(self):\n",
    "        return iter(self._children)\n",
    "\n",
    "    def depth_first(self):\n",
    "        yield self\n",
    "        for c in self:\n",
    "            yield from c.depth_first()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "id": "7b3f5d24",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Node(0) Node(1) Node(3) Node(4) Node(2) Node(5) "
     ]
    }
   ],
   "source": [
    "root = Node(0)\n",
    "child1 = Node(1)\n",
    "child2 = Node(2)\n",
    "root.add_child(child1)\n",
    "root.add_child(child2)\n",
    "child1.add_child(Node(3))\n",
    "child1.add_child(Node(4))\n",
    "child2.add_child(Node(5))\n",
    "\n",
    "for ch in root.depth_first():\n",
    "    print(ch, end=' ')         # Node(0) Node(1) Node(3) Node(4) Node(2) Node(5) "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bd86093b",
   "metadata": {},
   "source": [
    "### 역방향 순환"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "id": "82413d1e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4 3 2 1 "
     ]
    }
   ],
   "source": [
    "a = [1,2,3,4]\n",
    "# i = iter(a)\n",
    "# print(next(i))\n",
    "# print(next(i))\n",
    "# print(next(i))\n",
    "# print(next(i))\n",
    "\n",
    "# for x in a:\n",
    "#     print(x, end=' ')\n",
    "\n",
    "for x in reversed(a):     # __reversed__\n",
    "    print(x, end=' ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "id": "e56b2979",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Forward:\n",
      "5 4 3 2 1 \n",
      "\n",
      "Reverse:\n",
      "1 2 3 4 5 "
     ]
    }
   ],
   "source": [
    "class Countdown:\n",
    "    def __init__(self, start):\n",
    "        self.start = start\n",
    "\n",
    "    def __iter__(self):\n",
    "        n = self.start\n",
    "        while n > 0:\n",
    "            yield n\n",
    "            n -= 1\n",
    "\n",
    "    def __reversed__(self):\n",
    "        n = 1\n",
    "        while n <= self.start:\n",
    "            yield n\n",
    "            n += 1\n",
    "            \n",
    "# c = Countdown(3)\n",
    "# i = iter(c)\n",
    "# print(next(i))\n",
    "# print(next(i))\n",
    "# print(next(i))\n",
    "\n",
    "c = Countdown(5)\n",
    "print(\"Forward:\")\n",
    "for x in c:\n",
    "    print(x, end=' ')\n",
    "print('\\n')\n",
    "print(\"Reverse:\")\n",
    "for x in reversed(c):\n",
    "    print(x, end=' ')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "id": "d0bd9710",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1:When the tree is modified\n",
      "2:the new tree  python\n",
      "2:the new tree  python\n",
      "3:to restore \n",
      "4:constrain python\n",
      "4:constrain python\n",
      "5:The properties \n",
      "6:recoloring can  python"
     ]
    }
   ],
   "source": [
    "from collections import deque\n",
    "\n",
    "class linehistory:\n",
    "    def __init__(self, lines, histlen=3):\n",
    "        self.lines = lines\n",
    "        self.history = deque(maxlen=histlen)\n",
    "\n",
    "    def __iter__(self):\n",
    "        for lineno, line in enumerate(self.lines,1):\n",
    "            self.history.append((lineno, line))\n",
    "            yield line\n",
    "\n",
    "    def clear(self):\n",
    "        self.history.clear()\n",
    "        \n",
    "with open('somefile.txt') as f:\n",
    "    lines = linehistory(f)\n",
    "    for line in lines:\n",
    "        if 'python' in line:\n",
    "            for lineno, hline in lines.history:\n",
    "                print('{}:{}'.format(lineno, hline), end='')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8a921689",
   "metadata": {},
   "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.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}