python3.6/python06.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n",
    "***\n",
    "# 6. 제어문과 함수 기초\n",
    "***\n",
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n",
    "## 1 파이썬 제어문\n",
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1-1 들여쓰기와 제어문"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 파이썬은 들여쓰기를 강제하여 코드의 가독성을 높인다.\n",
    "- 가장 바깥쪽의 코드는 반드시 1열에 시작한다.\n",
    "- 블록 내부에 있는 statement들은 동일한 열에 위치해야 한다.\n",
    "- 블록의 끝은 들여쓰기가 끝나는 부분으로 간주된다.\n",
    "  - python에는 {, }, begin, end 등의 키워드가 존재하지 않는다.\n",
    "- 들여쓰기를 할 때에는 탭과 공백을 섞어 쓰지 않는다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "ename": "IndentationError",
     "evalue": "unexpected indent (<ipython-input-1-0453a5e2fe16>, line 2)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-1-0453a5e2fe16>\"\u001b[0;36m, line \u001b[0;32m2\u001b[0m\n\u001b[0;31m    a = 1 # 실패\u001b[0m\n\u001b[0m    ^\u001b[0m\n\u001b[0;31mIndentationError\u001b[0m\u001b[0;31m:\u001b[0m unexpected indent\n"
     ]
    }
   ],
   "source": [
    "a = 1 # 성공\n",
    " a = 1 # 실패"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "ename": "IndentationError",
     "evalue": "unexpected indent (<ipython-input-2-c77db9f95c1e>, line 3)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-2-c77db9f95c1e>\"\u001b[0;36m, line \u001b[0;32m3\u001b[0m\n\u001b[0;31m    print('really?')\u001b[0m\n\u001b[0m    ^\u001b[0m\n\u001b[0;31mIndentationError\u001b[0m\u001b[0;31m:\u001b[0m unexpected indent\n"
     ]
    }
   ],
   "source": [
    "if a > 1:\n",
    "    print('big')\n",
    "     print('really?')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1-2 if문\n",
    "- if문의 형식\n",
    "\n",
    "> if 조건식1:\n",
    "\n",
    "> &nbsp;&nbsp;statements\n",
    "\n",
    "> elif 조건식2:\n",
    "\n",
    "> &nbsp;&nbsp;statements\n",
    "\n",
    "> elif 조건식3:\n",
    "\n",
    "> &nbsp;&nbsp;statements\n",
    "\n",
    "> else:\n",
    "\n",
    "> &nbsp;&nbsp;statements\n",
    "\n",
    "- 조건식이나 else 다음에 콜론(:) 표기 필요\n",
    "- 들여쓰기(indentation)를 잘 지켜야 함"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Congratulations!!! \n"
     ]
    }
   ],
   "source": [
    "score = 90\n",
    "if score >= 90:\n",
    "    print('Congratulations!!! ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Big\n"
     ]
    }
   ],
   "source": [
    "a = 10\n",
    "if a > 5:\n",
    "    print('Big')\n",
    "else:\n",
    "    print('Small')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- statement가 1개인 경우 조건식과 한 줄에 위치 가능 (추천하지는 않음)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Big\n"
     ]
    }
   ],
   "source": [
    "a = 10\n",
    "if a > 5: print('Big')\n",
    "else: print('Small')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Negative\n"
     ]
    }
   ],
   "source": [
    "n = -2\n",
    "if n > 0:\n",
    "    print('Positive')\n",
    "elif n < 0:\n",
    "    print('Negative')\n",
    "else:\n",
    "    print('Zero')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "900\n"
     ]
    }
   ],
   "source": [
    "order = 'spagetti'\n",
    "\n",
    "if order == 'spam':\n",
    "    price = 500\n",
    "elif order == 'ham':\n",
    "    price = 700\n",
    "elif order == 'egg':\n",
    "    price = 300\n",
    "elif order == 'spagetti':\n",
    "    price = 900\n",
    "    \n",
    "print(price)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 위 코드와 동일한 dictionary 자료구조를 사용한 코드"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "900\n"
     ]
    }
   ],
   "source": [
    "order = 'spagetti'\n",
    "menu = {'spam':500, 'ham':700, 'egg':300, 'spagetti':900}\n",
    "price = menu[order]\n",
    "print(price)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1-3 for문\n",
    "\n",
    "> for <타겟> in <컨테이너 객체>:\n",
    "\n",
    "> &nbsp;&nbsp;statements\n",
    "\n",
    "> else:\n",
    "\n",
    "> &nbsp;&nbsp;statements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3 cat\n",
      "3 cow\n",
      "5 tiger\n"
     ]
    }
   ],
   "source": [
    "a = ['cat', 'cow', 'tiger']\n",
    "for x in a:\n",
    "    print(len(x), x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3 "
     ]
    }
   ],
   "source": [
    "for x in [1,2,3]:\n",
    "    print(x, end=\" \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "range(0, 10)\n",
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
      "0 1 2 3 4 5 6 7 8 9 "
     ]
    }
   ],
   "source": [
    "print(range(10))\n",
    "\n",
    "print(list(range(10)))\n",
    "\n",
    "for x in range(10):\n",
    "      print(x, end=\" \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "55\n"
     ]
    }
   ],
   "source": [
    "sum = 0\n",
    "for x in range(1, 11):\n",
    "    sum = sum + x\n",
    "    \n",
    "print(sum)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3628800\n"
     ]
    }
   ],
   "source": [
    "prod = 1\n",
    "for x in range(1, 11):\n",
    "    prod = prod * x\n",
    "    \n",
    "print(prod)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- enumerate() 내장 함수: 컨테이너 객체가 지닌 각 요소값뿐만 아니라 인덱스 값도 함께 반환한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 cat\n",
      "1 dog\n",
      "2 bird\n",
      "3 pig\n"
     ]
    }
   ],
   "source": [
    "l = ['cat', 'dog', 'bird', 'pig']\n",
    "for k, animal in enumerate(l):\n",
    "    print(k, animal)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 cat\n",
      "1 dog\n",
      "2 bird\n",
      "3 pig\n"
     ]
    }
   ],
   "source": [
    "t = ('cat', 'dog', 'bird', 'pig')\n",
    "for k, animal in enumerate(t):\n",
    "    print(k, animal)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 c cat\n",
      "1 d dog\n",
      "2 b bird\n",
      "3 p pig\n"
     ]
    }
   ],
   "source": [
    "d = {'c':'cat', 'd':'dog', 'b':'bird', 'p':'pig'}\n",
    "for k, key in enumerate(d):\n",
    "    print(k, key, d[key])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- break: 루프를 빠져나간다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "done\n"
     ]
    }
   ],
   "source": [
    "for x in range(10):\n",
    "    if x > 3: \n",
    "        break\n",
    "    print(x)\n",
    "    \n",
    "print('done')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- continue: 루프 블록 내의 continue 이후 부분은 수행하지 않고 루프의 시작부분으로 이동한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n",
      "9\n",
      "done\n"
     ]
    }
   ],
   "source": [
    "for x in range(10):\n",
    "    if x < 8:\n",
    "        continue\n",
    "    print(x)\n",
    "    \n",
    "print('done')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- else: 루프가 break에 의한 중단 없이 정상적으로 모두 수행되면 else 블록이 수행된다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 1 2 3 4 5 6 7 8 9 else block\n",
      "done\n"
     ]
    }
   ],
   "source": [
    "for x in range(10):\n",
    "    print(x, end=\" \")         \n",
    "else:\n",
    "    print('else block')\n",
    "\n",
    "print('done')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- break에 의하여 루프를 빠져나가면 else 블록도 수행되지 않는다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "done\n"
     ]
    }
   ],
   "source": [
    "for x in range(10):\n",
    "    break\n",
    "    print(x, end=\" \")\n",
    "else:\n",
    "    print('else block')\n",
    "    \n",
    "print('done')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- for 루프의 중첩"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 * 2 = 4\n",
      "2 * 3 = 6\n",
      "2 * 4 = 8\n",
      "2 * 5 = 10\n",
      "2 * 6 = 12\n",
      "2 * 7 = 14\n",
      "2 * 8 = 16\n",
      "2 * 9 = 18\n",
      "\n",
      "3 * 2 = 6\n",
      "3 * 3 = 9\n",
      "3 * 4 = 12\n",
      "3 * 5 = 15\n",
      "3 * 6 = 18\n",
      "3 * 7 = 21\n",
      "3 * 8 = 24\n",
      "3 * 9 = 27\n",
      "\n"
     ]
    }
   ],
   "source": [
    "for x in range(2, 4):\n",
    "    for y in range(2, 10):\n",
    "        print(x, '*', y, '=', x*y)\n",
    "    print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 * 2 = 4\n",
      "2 * 3 = 6\n",
      "2 * 4 = 8\n",
      "2 * 5 = 10\n",
      "2 * 6 = 12\n",
      "2 * 7 = 14\n",
      "2 * 8 = 16\n",
      "2 * 9 = 18\n",
      "\n",
      "3 * 2 = 6\n",
      "3 * 3 = 9\n",
      "3 * 4 = 12\n",
      "3 * 5 = 15\n",
      "3 * 6 = 18\n",
      "3 * 7 = 21\n",
      "3 * 8 = 24\n",
      "3 * 9 = 27\n",
      "\n"
     ]
    }
   ],
   "source": [
    "for x in range(2, 4):\n",
    "    for y in range(2, 10):\n",
    "        print(\"{0} * {1} = {2}\".format(x, y, x * y))\n",
    "    print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1-4 while문"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- while 조건식이 만족하는 동안 while 블록내의 statements 들을 반복 수행한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "count = 1\n",
    "while count < 11:\n",
    "    print(count)\n",
    "    count = count + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "55\n"
     ]
    }
   ],
   "source": [
    "sum = 0\n",
    "a = 0\n",
    "while a < 10:\n",
    "    a = a + 1\n",
    "    sum = sum + a\n",
    "print(sum)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 1 2 3 4 5 6 7 8 9 else block\n",
      "done\n"
     ]
    }
   ],
   "source": [
    "x = 0\n",
    "while x < 10:\n",
    "    print(x, end=\" \")\n",
    "    x = x + 1\n",
    "else:\n",
    "    print('else block')\n",
    "\n",
    "print('done')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n",
    "## 2 파이썬 함수 기초\n",
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2-1. 함수의 장점 및 함수 사용법\n",
    "- 함수의 장점\n",
    "  - 함수는 반복적인 코드를 없에 주어 코드의 길이를 짧게 만들어 준다.\n",
    "  - 코드의 유지보수를 쉽게 만들어 준다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n",
      "[1, 2, 3, 4, 5, 6]\n"
     ]
    }
   ],
   "source": [
    "def add(a, b):\n",
    "    return a + b\n",
    "\n",
    "print(add(3, 4))\n",
    "\n",
    "print(add([1,2,3], [4,5,6]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "40\n"
     ]
    }
   ],
   "source": [
    "c = add(10, 30)\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 함수 이름에 저장된 레퍼런스를 다른 변수에 할당하여 그 변수를 이용한 함수 호출 가능"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n",
      "<function add at 0x1037c01e0>\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "f = add\n",
    "print(f(4, 5))\n",
    "\n",
    "print(f)\n",
    "\n",
    "print(f is add)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 함수의 몸체에는 최소한 한개 이상의 statement가 존재해야 함\n",
    "  - 그러므로, 아무런 내용이 없는 몸체를 지닌 함수를 만들 때에는 pass 라는 키워드를 몸체에 적어주어야 함"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n"
     ]
    }
   ],
   "source": [
    "def simple():\n",
    "    pass\n",
    "\n",
    "print(simple())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 함수에서 다른 함수 호출 가능"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12\n"
     ]
    }
   ],
   "source": [
    "def add(a, b):\n",
    "    return a + b\n",
    "\n",
    "def myabs(x):\n",
    "    if x < 0: \n",
    "        x = -x\n",
    "    return x\n",
    "\n",
    "def addabs(a, b):\n",
    "    c = add(a, b)\n",
    "    return myabs(c)\n",
    "\n",
    "print(addabs(-5, -7))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 인자의 이름과 함께 인자 값을 넘겨줄 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-8\n",
      "-8\n"
     ]
    }
   ],
   "source": [
    "def minus(a, b):\n",
    "    return a - b\n",
    "print(minus(a=12, b=20))\n",
    "print(minus(b=20, a=12))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 인자의 디폴트 값을 지정할 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n",
      "15\n"
     ]
    }
   ],
   "source": [
    "def incr(x, y=1):\n",
    "    return x + y\n",
    "\n",
    "print(incr(5))\n",
    "\n",
    "print(incr(5, 10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 두 개 이상의 값을 동시에 반환할 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(12, 8, 20, 5.0)\n"
     ]
    }
   ],
   "source": [
    "def calc(x, y):\n",
    "    return x + y, x - y, x * y, x / y\n",
    "\n",
    "print(calc(10, 2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2-2 함수 호출시 동적인 자료형 결정"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 파이썬에서는 모든 객체는 동적으로 (실행시간에) 그 타입이 결정된다.\n",
    "  - 함수 인자는 함수가 호출되는 순간 해당 인자에 전달되는 객체에 따라 그 타입이 결정된다.\n",
    "  - 함수 몸체 내에서 사용되는 여러 가지 연산자들은 함수 호출시에 결정된 객체 타입에 맞게 실행된다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4.4\n",
      "dynamictyping\n",
      "['list', 'and', 'list']\n"
     ]
    }
   ],
   "source": [
    "def add(a, b):\n",
    "    return a + b\n",
    "\n",
    "c = add(1, 3.4)\n",
    "d = add('dynamic', 'typing')\n",
    "e = add(['list'], ['and', 'list'])\n",
    "print(c)\n",
    "print(d)\n",
    "print(e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2-3 재귀적 함수 호출\n",
    "- 재귀(Recursive) 함수: 함수 몸체에서 자기 자신을 호출하는 함수\n",
    "  - 수학에서 점화식과 유사한 코드\n",
    "  - 반드시 종결 조건 및 종결 조건이 만족할 때의 반환 값이 있어야 한다.\n",
    "\n",
    "- 1부터 N까지 더하는 재귀 함수"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "55\n"
     ]
    }
   ],
   "source": [
    "def sum(N):\n",
    "    if N == 1:           # 종결 조건\n",
    "        return 1         # 종결 조건이 만족할 때의 반환 값\n",
    "    return N + sum(N-1)  # 재귀 호출\n",
    "\n",
    "print(sum(10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style='text-align: right;'>참고 문헌: 파이썬(열혈강의)(개정판 VER.2), 이강성, FreeLec, 2005년 8월 29일</p>"
   ]
  }
 ],
 "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.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}