notebooks/PiPy03B-Functions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 기본 자료형: 함수"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "_[Think Python의 3장](http://greenteapress.com/thinkpython2/html/thinkpython2004.html) \n",
    "내용을 요약 및 수정한 내용입니다._"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 함수 정의하기"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "파이썬에서 함수의 정의는 아래 형식을 이용해야 한다.\n",
    "\n",
    "```python\n",
    "def 함수이름(매개변수1, 매개변수2, ..., 매개변수n):\n",
    "    명령문\n",
    "    return 표현식\n",
    "```\n",
    "\n",
    "**주의:** 함수 본체에 사용되는 명령문은 들여쓴다.\n",
    "\n",
    "함수를 정의할 때 사용되는 **매개변수**는 인자로 들어오는 값들을\n",
    "함수 본체 명령문에 전달하는 역할을 수행한다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 예제"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "절댓값을 계산하는 함수 `myAbs`와\n",
    "두 숫자의 합을 계산하는 함수 `myAdd`를 아래와 같이 직접 정의할 수 있다.\n",
    "\n",
    "`myAbs`는 한 개의 값을 입력받아야 하기에 한 개의 매개변수가 필요하고,\n",
    "반면에 `myAdd`는 더해야 할 두 개의 값을 입력받아야 하기에 두 개의 매개변수가 필요하다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "def myAbs(num):\n",
    "    if num >= 0:\n",
    "        z = num\n",
    "    else:\n",
    "        z = -num\n",
    "    return z\n",
    "\n",
    "def myAdd(left, right):\n",
    "    z = left + right\n",
    "    return z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myAbs(-3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myAdd(-3, myAbs(-3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 매개변수와 인자"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`myAbs`와 `myAdd`의 정의헤서 사용된 \n",
    "`num`, `left`, `right` 등은 함수의 인자를 받아들이는데 사용되는 **매개변수**이다.\n",
    "그리고 매개변수를 통해 함수에게 전달되는 값들을 **인자**라고 부른다. \n",
    "사용되는 인자의 개수는 매개변수의 개수와 일치해야 한다.\n",
    "\n",
    "함수와 매개변수들의 이름은 각각의 역할에 맞게 정하는 것을 권유한다.\n",
    "그러면 함수와 매개변수들의 이름을 보고 함수와 각 매개변수들의 의미와 \n",
    "역할을 파악하는 데에 보다 유리하다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 옵션 인자"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`print` 함수를 이용하여 화면에 출력할 때 사용되는 인자의 수는 여러 개일 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, Python !\n"
     ]
    }
   ],
   "source": [
    "print('Hello,', 'Python', '!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "그런데 여러 개의 인자를 각각 다른 줄에 출력하려면 아래와 같이 하면 된다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello,\n",
      "Python\n",
      "!\n"
     ]
    }
   ],
   "source": [
    "print('Hello,', 'Python', '!', sep='\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "위에서 사용된 `sep`은 `print` 함수의 옵션 인자이다.\n",
    "`sep`과 같은 옵션 인자는 인자를 지정하지 않으면 기본값을 사용한다.\n",
    "`sep`의 기본값은 한 칸 띄어쓰기를 의미하는 `' '`이다.\n",
    "즉, `print` 함수의 인자들을 한 칸씩 띄어서 화면에 보여준다.\n",
    "그리고 위에서는 `sep`에 대한 인자를 띄어쓰기 대신 줄바꿈(`'\\n'`)을\n",
    "사용하였다.\n",
    "\n",
    "이렇듯 특정 함수들은 옵션 인자를 사용할 수 있으며, 그런 함수는\n",
    "매개변수에 기본값을 지정하는 식으로 정의된다.\n",
    "\n",
    "예를 들어, `print`함수에 사용되는 매개변수 중에\n",
    "`sep` 이외에 `end`, `file`, `flush` 등이 기본값을 갖는다.\n",
    "실제로 `help(print)` 명령문을 실행하면\n",
    "아래와 같이 확인된다.\n",
    "\n",
    "```python\n",
    "print(value, ..., sep=' ', end='\\n', file=sys.stdout, flush=False)\n",
    "```\n",
    "\n",
    "* `sep` 매개변수: 출력할 인자들 사이에 대한 기준 지정. 기본값은 띄어쓰기.\n",
    "* `end` 매개변수: 화면 출력 후 추가로 할 일에 대한 기준 지정. 기본값은 줄바꿈.\n",
    "* `file` 매개변수: 출력 장치 지정. 기본값은 터미널 화면.\n",
    "* `flush` 매개변수: 여러 개의 출력값들을 하나씩 차례대로 출력 장치에 보낼지 말지를 지정. 기본값은 하나씩 바로바로 보내기.\n",
    "\n",
    "위 옵션 매개변수 중에서 `sep`과 `end`는 여러 모로 유용하게 활용할 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function print in module builtins:\n",
      "\n",
      "print(...)\n",
      "    print(value, ..., sep=' ', end='\\n', file=sys.stdout, flush=False)\n",
      "    \n",
      "    Prints the values to a stream, or to sys.stdout by default.\n",
      "    Optional keyword arguments:\n",
      "    file:  a file-like object (stream); defaults to the current sys.stdout.\n",
      "    sep:   string inserted between values, default a space.\n",
      "    end:   string appended after the last value, default a newline.\n",
      "    flush: whether to forcibly flush the stream.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(print)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 예제"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "옵션 인자를 사용하는 함수를 정의할 수 있다.\n",
    "아래 함수는 두 개의 숫자를 입력받아 합을 구한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def myAdd10(left, right=10):\n",
    "    add10 = left + right\n",
    "    return add10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "그런데, 둘째 매개변수의 기본값이 10으로 지정되었다.\n",
    "따라서 둘째 인자를 반드시 입력하지 않아도 되며,\n",
    "그럴 경우 둘째 인자는 10으로 처리된다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myAdd10(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "물론 둘째 인자를 지정할 수도 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "25"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myAdd10(5, 20)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "옵션 매개변수의 값을 지정하고잘 할 경우 매개변수 이름을 언급하는 것이 좋다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "25"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myAdd10(5, right=20)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 수학과 프로그래밍에서의 함수 이해"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 수학에서의 함수"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "함수라는 표현이 수학에서 많이 사용된다. \n",
    "수학에서 함수는 두 집합 사이의 관계이며,\n",
    "첫째 집합의 원소를 둘째 집합의 원소와 대응시킨다. \n",
    "\n",
    "아래 그림은 집합 $X$의 원수 $x$와 집합 $Y$의 원소 $f(x)$를 대응시키는 함수를 보여준다.\n",
    "\n",
    "<p>\n",
    "<table cellspacing=\"20\">\n",
    "<tr>\n",
    "<td>\n",
    "<img src=\"images/fun_math1.png\">\n",
    "</td>\n",
    "</tr>\n",
    "</table>\n",
    "</p>\n",
    "\n",
    "<그림 출처: [함수, 위키백과](https://ko.wikipedia.org/wiki/함수)>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "이때 $X$와 $Y$를 각각 함수 $f$의 **정의역**(domain)과 \n",
    "**공역**(codomain)이라 부른다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 프로그래밍에서의 함수"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "프로그래밍에서 함수가 하는 역할은 다음과 같다. \n",
    "\n",
    "> 어떤 값이 입력(input)되면 그 값을 이용하여 특정 수식에 따라 계산한 후 \n",
    "    특정 값을 내준다(output).\n",
    "  \n",
    "아래 그림은 함수의 입력(input)과 내주기(output)의 관계를 보여준다.\n",
    "\n",
    "<p>\n",
    "<table cellspacing=\"20\">\n",
    "<tr>\n",
    "<td>\n",
    "<img src=\"images/fun_prog2.png\">\n",
    "</td>\n",
    "</tr>\n",
    "</table>\n",
    "</p>\n",
    "\n",
    "<그림 출처: [함수, 위키백과](https://ko.wikipedia.org/wiki/함수)>\n",
    "\n",
    "함수의 입력값으로 사용될 수 있는 값들의 집합이 정의역에 해당하고,\n",
    "내주는 값들의 집합이 공역에 해당한다.\n",
    "함수가 내주는 값을 **리턴값**이라 부르기도 한다.\n",
    "이유는 함수가 내주는 값을 보통 `return` 지정자로 지정하기 때문이다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 차이점"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "입력값을 특정 집합의 원소로 보고, 리턴값을 다른 집합의 원소로 보고,\n",
    "그리고 \n",
    "두 집합 사이의 대응관계를 \"수식에 따라 계산한다\"라 이해한다면 \n",
    "수학과 프로그래밍에서의 함수 개념은 동일하다.\n",
    "\n",
    "* 정의역: 함수의 입력값들로 구성된 집합\n",
    "* 공역: 함수의 리턴값들로 구성된 집합\n",
    "\n",
    "실제로, 수학 함수를 프로그래밍 함수로 다룰 수 있다. \n",
    "예를 들어, 절댓값 함수는 실수에서 실수로 가는 함수이며,\n",
    "양수는 그대로 두고, 음수는 부호를 바꿔 양수로 만든다. \n",
    "\n",
    "절댓값에 해당하는 프로그래밍 함수는 `abs`이며, 아래와 같이 작동한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.3"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "abs(-3.3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "위에서 사용된 표현식 `abs(-3.3)`과 그 결과인 `3.3`의 역할은 다음과 같다.\n",
    "\n",
    "* `abs`: 절댓값 함수를 가리키는 이름\n",
    "* `-3.3`: 입력값\n",
    "* `3.3`: 리턴값"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 프로그래밍 함수의 정의역"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "앞서 프로그래밍 함수의 입력값들로 구성된 집합이 수학 함수의 정의역에 \n",
    "해당한다고 설명하였다.\n",
    "그런데 주의사항이 하나 있다.\n",
    "\n",
    "파이썬의 경우, 함수의 입력값에 어떤 제한도 없기 때문이다.\n",
    "다만, 의도하지 않은 값이 사용될 경우, 함수의 실행 과정에서 오류가 발생한다.\n",
    "예를 들어, `abs` 함수를 문자열과 함께 실행하면 \n",
    "`TypeError`, 즉, 인자의 자료형에 문제가 있다는 오류가 발생한다.\n",
    "이유는 `abs` 함수가 숫자만 다룰 수 있기 때문이다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "bad operand type for abs(): 'str'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-12-952b1624c912>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mabs\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'python'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: bad operand type for abs(): 'str'"
     ]
    }
   ],
   "source": [
    "abs('python')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "따라서 프로그래밍 함수의 정의역은 입력값들 중에서 오류가 발생하지 않는 값들의 집합으로\n",
    "보는 게 보다 더 적절하다.\n",
    "하지만, 이것을 프로그래밍 함수의 정의역으로 **정의**(define)하지는 않을 것이다.\n",
    "프로그래밍 함수의 정의역을 엄밀하게 정의하는 일은 보다 복잡하기에,\n",
    "자세히 다루지 않는다. \n",
    "다만, 개념적으로 프로그래밍 함수와 수학 함수가 유사한 면이 많다라는 정도만\n",
    "기억해두면 좋다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 프로그래밍 함수 예제"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "프로그래밍에서는 다루는 함수 유형을 살펴본다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 수학 함수와 유사한 경우\n",
    "\n",
    "* 수를 입력하면 계산결과를 돌려준다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "def toto1(x):\n",
    "    y = x**2+1\n",
    "    return y\n",
    "    \n",
    "print(toto1(3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 아래 함수는 변수이름 `y`를 지역변수와 전역변수로 동시에 사용했다.\n",
    "    하지만 서로 관계가 없기 때문에 일반 수학 함수처럼 작동한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-1 10\n"
     ]
    }
   ],
   "source": [
    "y = -1\n",
    "\n",
    "def toto2(x):\n",
    "    y = x**2+1\n",
    "    return y\n",
    "\n",
    "# 전역변수 y는 함수와 아무 상관 없음.\n",
    "print(y, toto2(3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 -1\n"
     ]
    }
   ],
   "source": [
    "y = -1\n",
    "\n",
    "def toto3(x):\n",
    "    y = x**2+1\n",
    "    return y\n",
    "\n",
    "# 전역변수 y는 함수와 아무 상관 없음.\n",
    "print(toto3(3), y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 수학 함수와 조금 다른 경우"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 아래 함수는 함수 안에서 전역변수 `y`를 업데이트한다.\n",
    "    이렇게 하면 `y`가 가리키는 값은 `toto` 함수의 호출에\n",
    "    민감하게 반응한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 10\n"
     ]
    }
   ],
   "source": [
    "y = -1\n",
    "\n",
    "def toto4(x):\n",
    "    global y\n",
    "    y = x**2+1\n",
    "    return y\n",
    "\n",
    "# toto 함수가 실행되면 y 가 업데이트 됨.\n",
    "print(toto4(3), y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-1 10\n"
     ]
    }
   ],
   "source": [
    "y = -1\n",
    "\n",
    "def toto5(x):\n",
    "    global y\n",
    "    y = x**2+1\n",
    "    return y\n",
    "\n",
    "# y 값을 먼저 확인 한 후에 toto 함수가 실행\n",
    "print(y, toto5(3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 수학 함수와 많이 다른 경우"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 함수의 리턴값이 지정되지 않으면 `None`을 내줌.\n",
    "* `None`은 아무런 의미가 없는 값임.\n",
    "* 대신에 아래 함수를 실행하면 변수 `y`의 값을 업데이트 함.\n",
    "* 수학엔 이런 함수 없음."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None 10\n"
     ]
    }
   ],
   "source": [
    "y = -1\n",
    "\n",
    "def toto6(x):\n",
    "    global y\n",
    "    y = x**2+1\n",
    "    \n",
    "print(toto6(3), y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-1 None\n"
     ]
    }
   ],
   "source": [
    "y = -1\n",
    "\n",
    "def toto7(x):\n",
    "    global y\n",
    "    y = x**2+1\n",
    "    \n",
    "print(y, toto7(3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 함수의 리턴값<a id='funReturn'></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "앞서 살펴 보았던 `toto1`~`toto5` 같은 함수의 경우 `return` 지정자 이후에 \n",
    "위치한 값 `y`를 내주는(output) 값으로 지정한다.\n",
    "즉, 숫자 `x`를 입력(input)값으로 사용하여 실행하면\n",
    "종료하기 전에 \n",
    "`y`가 가리키는 값 `x**2+1`를 내준다.\n",
    "이렇게 함수가 실행을 종료하면서 내주는 값을 **리턴값**이라 부른다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 리턴값이 명시되지 않은 함수"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`toto6`와 `toto7`은 `return` 지정자를 사용하지 않았다.\n",
    "이런 경우 파이썬은 암묵적으로 `return None`을 지정한다.\n",
    "즉, 리턴값이 항상 `None` 값인 것이다.\n",
    "\n",
    "**주의:** `None`은 아무런 의미를 갖지 않는 값이다.\n",
    "\n",
    "파이선 내장함수(built-in functions)들 중에 \n",
    "`print` 함수가 리턴값이 명시되지 않은 대표적인 함수이다. \n",
    "예를 들어, 아래 코드는 `print` 함수의 리턴값을 확인할 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "x = print(1)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**주의:** 위 코드를 실행한 결과의 첫째 줄에서 보이는 `1`은 `print` 함수의 리턴값이 아니라,\n",
    "`print(1)`을 실행하여 모니터에 숫자 1을 출력하는 `print` 함수의 \n",
    "**부수효과**(side effect)에 불과하다.\n",
    "함수의 부수효과에 대해서는 아래에서 좀 더 자세히 다룬다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 함수의 리턴값은 단 하나"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "함수 본체 코드에 `return` 지정자가 여러 번 사용되더라도 \n",
    "함수를 실행할 때 내주는 값은 무조건 하나이다.\n",
    "\n",
    "예를 들어, 아래 `login` 함수는\n",
    "`members` 리스트에 아이디가 포함되어 있는지 여부를 \n",
    "판단한다.\n",
    "\n",
    "`login` 함수 본체에 `return` 지정자가 두 번 사용되었다.\n",
    "하지만, `members`에 포함된 항목별로 회원여부를 판단할 때\n",
    "회원이 확인되면 '누구누구님 환영합니다'를 리턴하고\n",
    "바로 함수의 실행을 종료한다. \n",
    "즉, 더이상 `for` 반복문을 돌리지 않는다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "members = ['egoing', 'k8805', 'leezche']\n",
    "\n",
    "def login(_id):\n",
    "    for member in members:\n",
    "        if member == _id:\n",
    "            return f'{member}님 환영합니다.'\n",
    "    return '회원이 아닙니다.'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'egoing님 환영합니다.'"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "login('egoing')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'k8805님 환영합니다.'"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "login('k8805')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'회원이 아닙니다.'"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "login('liga')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 함수호출"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "앞서 살펴 보았듯이 함수의 리턴값을 저장하거나 다른 함수의 인자로 전달할 수 있다.\n",
    "즉, 하나의 값으로 다룰 수 있으며,\n",
    "이렇게 함수를 이용하여 표현된 값을 **함수 표현식**이라 부른다. \n",
    "\n",
    "예를 들어, 절댓값을 생성하는 함수인 `abs`에 부동소수점 `-3.3`을 \n",
    "인자로 사용하여 표현된 값은 아래와 같다.\n",
    "\n",
    "```python\n",
    "abs(-3.3)\n",
    "```\n",
    "\n",
    "또한, 실수 `abs(-3.3)`를 -3.3과 더해주려면 아래와 표현식처럼\n",
    "함수의 합성을 이용할 수 있다.\n",
    "\n",
    "```python\n",
    "myAdd(abs(-3.3), -3.3)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "하지만 함수 표현식이 가리키는 값을 실제로 확인하려면 \n",
    "함수를 해당 인자와 함께 실행해야 한다.\n",
    "이렇게 함수 표현식을 실행하는 것을 **함수호출**이라 부른다.\n",
    "\n",
    "예를 들어, 앞서 언급한 두 표현식의 호출해서 결과를 확인하려면 아래와 같이 할 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.3\n"
     ]
    }
   ],
   "source": [
    "print(abs(-3.3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.0\n"
     ]
    }
   ],
   "source": [
    "sumZero = myAdd(abs(-3.3), -3.3)\n",
    "print(sumZero)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 함수호출 실행과정"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "함수호출 과정을 좀 더 자세히 살펴보자.\n",
    "예를 들어, 아래 함수 표현식이 가리키는 값이 어떤 순서대로 계산되는가를 확인하고 한다.\n",
    "\n",
    "```python\n",
    "mul(add(2, mul(0x4, 0x6)), add(0x3, 0o5))\n",
    "```\n",
    "\n",
    "* `add` 함수와 `mul` 함수는 각각 두 숫자의 합과 곱을 계산하는 함수이며, \n",
    "    `operator` 모듈에 포함되어 있다.\n",
    "* `0x`로 시작하는 숫자는 16진법을 의미한다.\n",
    "* `0o`로 시작하는 숫자는 8진법을 의미한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "208"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from operator import add, mul\n",
    "\n",
    "mul(add(2, mul(0x4, 0x6)), add(0x3, 0o5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "최종적으로 208이 계산되는 과정을 그림으로 나타내면 다음과 같다.\n",
    "아래 그림에서 &#9312; ~ &#9319;번 사이의 번호가 배정된 네모상자로 둘러싸인 부분이 \n",
    "현재 실행중인 함수호출 또는 함수호출의 결과값을 나타낸다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>\n",
    "<table cellspacing=\"20\">\n",
    "<tr>\n",
    "<td>\n",
    "<img src=\"images/fun_call.png\">\n",
    "</td>\n",
    "</tr>\n",
    "</table>\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 예제"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[PythonTutor: 함수호출 실행과정](http://pythontutor.com/visualize.html#code=def%20myAdd%28left,%20right%29%3A%0A%20%20%20%20return%20left%2Bright%0A%20%20%20%20%0Adef%20myMul%28left,%20right%29%3A%0A%20%20%20%20return%20left*right%0A%0AmyMul%28myAdd%282,%20myMul%280x4,%200x6%29%29,%20myAdd%280x3,%200o5%29%29&cumulative=false&curInstr=0&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false)에서\n",
    "앞서 사용한 표현식과 동일하게 작동하는 표현식이 계산되는 과정을 살펴볼 수 있다.\n",
    "\n",
    "**주의:** `add`, `mul`과 같이 파이썬에서 이미 정의된 내장함수들의 계산과정은 시각화해서 보여지지 않는다.\n",
    "그래서 동일하게 작동하는 `myAdd`와 `myMul`을 새로 정의하였다.\n",
    "함수의 이름만 다를 뿐 동일한 표현식이다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 함수호출의 부수효과"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "프로그램에서 사용되는 함수를 구분하는 다양한 기준이 있다.\n",
    "여기서는 부수기능의 존재여부에 따른 함수 분류 기준을 살펴본다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 부수효과가 없는 함수 (Pure functions)\n",
    "\n",
    "함수가 호출되어 실행되어 실행결과를 리턴값으로 내줄 때까지 \n",
    "실행결과를 생성하기 위한 일 이외에 다른 어떤 일도 하지 않는다면 \n",
    "그 함수를 부수효과가없는 함수라 부른다.\n",
    "\n",
    "예를 들어 절대값을 계산하는 `abs` 함수와 덧셈을 행하는 `add` 함수 등이 순수한 함수이다. \n",
    "아래 그림에서 보듯이 인자를 입력받은 후에 각각 절대값과 덧셈을 실행하여 결과값을 돌려주는 일 \n",
    "이외에는 다른 일을 행하지 않는다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>\n",
    "<table cellspacing=\"20\">\n",
    "<tr>\n",
    "<td>\n",
    "<img src=\"images/fun_pure.png\">\n",
    "</td>\n",
    "</tr>\n",
    "</table>\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 부수효과가 있는 함수 (Impure functions)\n",
    "\n",
    "부수효과가 있는 함수는 부수효과가 없는 함수와는 달리 결과값을 돌려주는 것 이외에 부수적인 일을 한다.\n",
    "대표적으로 파이썬 내장함수인 `print` 함수가 부수효과를 갖는 함수이다.\n",
    "\n",
    "그런데 `print`가 부수효과를 갖는 함수라는 것을 확인하려면 아래 두 가지를 알아야 한다.\n",
    "\n",
    "* 리턴하는 값이 무엇인가?\n",
    "* 부수적으로 어떤 일을 하는가?\n",
    "\n",
    "먼저, `print`가 리턴하는 값은 `None`이다. \n",
    "기타 언어에서는 보통 널(null) 값이라 부른다.\n",
    "\n",
    "다음으로, `print` 함수가 부수적으로 하는 일은 예를 들어 터미널 창에 어떤 문자열을 출력하는 것이다.\n",
    "`print(\"Hello Python\")` 방식으로 `print` 함수를 호출하면 아래와 같이 `'Hello Python'` 이란 문자열을 출력한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello Python\n"
     ]
    }
   ],
   "source": [
    "print(\"Hello Python\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "즉, `print(\"Hello Python\")`을 실행하였을 때 보여주는 \n",
    "`'Hello Python'`은 리턴값이 아니라 `print` 함수가 부수적으로 하는 일이다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 예제: 부수효과를 갖는 함수의 호출과정"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "부수효과를 갖는 함수호출의 실행과정은 부수효과가 없는 함수의 호출과정과 기본적으로 동일하다.\n",
    "하지만 중간중간에 부수적인 일도 함께 벌어진다.\n",
    "\n",
    "먼저 아래 코드의 실행결과가 어떻게 도출되었는가를 잘 생각해보자."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "None None\n"
     ]
    }
   ],
   "source": [
    "print(print(1), print(2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "아래의 그림은 위 코드를 호출하는 과정을 설명한다.\n",
    "아래 그림에서 &#9312; ~ &#9319;번 사이의 번호가 배정된 네모상자로 둘러싸인 부분이 \n",
    "현재 실행중인 함수호출 또는 함수호출의 결과값 또는 부수효과(화면 출력)를 나타낸다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>\n",
    "<table cellspacing=\"20\">\n",
    "<tr>\n",
    "<td>\n",
    "<img src=\"images/fun_print.png\">\n",
    "</td>\n",
    "</tr>\n",
    "</table>\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[PythonTutor: 함수호출 부수효과](http://pythontutor.com/visualize.html#code=def%20myPrint%28*args,%20**kwargs%29%3A%0A%20%20%20%20print%28*args,%20**kwargs%29%0A%0AmyPrint%28myPrint%281%29,%20myPrint%282%29%29&cumulative=false&curInstr=11&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false)에서\n",
    "앞서 사용한 표현식과 동일하게 작동하는 표현식이 계산되는 과정을 살펴볼 수 있다.\n",
    "\n",
    "**주의:** `print` 함수와 동일하게 작동하는 `myPrint` 함수를 사용했다.\n",
    "함수의 이름만 다를 뿐 동일한 표현식이다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 지역변수와 전역변수"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "함수를 선언할 때 사용되는 매개변수와 함수 본체에서 선언되는 변수는 함수가 실행되는 동안에만 의미를 갖는 변수들이며,\n",
    "이런 변수들을 **지역변수**라 부른다. \n",
    "지역변수 가인 변수들은 **전역변수**라 부른다.\n",
    "\n",
    "예를 들어, `hour_to_min` 함수를 정의할 때 사용된 \n",
    "`hour`와 본체에서 선언된 `minutes` 변수는 모두 지역함수이며,\n",
    "`two_hour` 는 함수 밖에서 선언된 전역변수이다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "def hour_to_min(hour):\n",
    "    minutes = hour * 60\n",
    "    return minutes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "지역변수들은 함수 밖에서는 어떤 의미도 갖지 않는다. 예를 들어, 아래 코드를 실행하면 오류가 발생한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'minutes' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-31-e7e4f4b2bcc2>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mtwo_hour\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mhour_to_min\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mminutes\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'minutes' is not defined"
     ]
    }
   ],
   "source": [
    "two_hour = hour_to_min(2)\n",
    "print(minutes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "물론 아래의 경우도 오류가 발생한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'hour' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-32-eadd17c83928>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mtwo_hour\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mhour_to_min\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mhour\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'hour' is not defined"
     ]
    }
   ],
   "source": [
    "two_hour = hour_to_min(2)\n",
    "print(hour)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "위에서 오류가 발생하는 이유는 `hour_to_min` 함수가 인자 2와 함께 실행되어 종료가 되면 \n",
    "실행도중에 선언되어 사용된 `hour`와 `minutes` 변수의 의미도 완전히 사라지기 때문이다.\n",
    "\n",
    "**참고:**\n",
    "[PythonTutor:지역변수 전역변수](http://pythontutor.com/visualize.html#code=def%20hour_to_min%28hour%29%3A%0A%20%20%20%20minutes%20%3D%20hour%20*%2060%0A%20%20%20%20return%20minutes%0A%0Atwo_hour%20%3D%20hour_to_min%282%29%0Aprint%28minutes%29&cumulative=false&curInstr=0&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false)에서\n",
    "`hour`와 `minutes`의 생존주기, 즉, 언제 생성되고 언제 사라지는지를 확인할 수 있다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 재귀함수"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "봉 감독의 영화(Movies by Bong, moBong)를 담고 있는 리스트가 아래와 같이 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "moBong = [\"기생충\", 2019, [\"설국열차\", 2013, [\"살인의 추억\", 2003]]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "위 리스트는 3중이다. 리스트 안에 리스트, 또 리스트 안에 리스트.\n",
    "이제 아래와 같이 모든 항목을 나열하고자 한다.\n",
    "\n",
    "```\n",
    "기생충\n",
    "2019\n",
    "설국열차\n",
    "2013\n",
    "살인의 추억\n",
    "2003\n",
    "```\n",
    "\n",
    "먼저, 위 리스트의 항목들을 하나씩 확인하려면 아래와 같이 `for` 반복문을 활용해보자."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "기생충\n",
      "2019\n",
      "['설국열차', 2013, ['살인의 추억', 2003]]\n"
     ]
    }
   ],
   "source": [
    "for item in moBong:\n",
    "    print(item)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "그런데 위와 같이 하면 중첩으로 되어 있는 영화들을 제대로 풀어헤칠 수 없다.\n",
    "2중 `for` 반복문을 활용해보자.\n",
    "\n",
    "**주의:** 아래 코드에서 `isinstance(item, list)`는 `item` 변수가 가리키는 항목이 \n",
    "리스트 자료형 여부를 확인한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "기생충\n",
      "2019\n",
      "설국열차\n",
      "2013\n",
      "['살인의 추억', 2003]\n"
     ]
    }
   ],
   "source": [
    "for item in moBong:\n",
    "    if isinstance(item, list):\n",
    "        for itemN in item:\n",
    "            print(itemN)\n",
    "    else:\n",
    "        print(item)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "여전히 삼중 리스트의 모든 항목을 나열하진 못한다. \n",
    "3중 `for` 반복문을 활용해보자."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "기생충\n",
      "2019\n",
      "설국열차\n",
      "2013\n",
      "살인의 추억\n",
      "2003\n"
     ]
    }
   ],
   "source": [
    "for item in moBong:\n",
    "    if isinstance(item, list):\n",
    "        for itemN in item:\n",
    "            if isinstance(itemN, list):\n",
    "                for itemNN in itemN:\n",
    "                    print(itemNN)\n",
    "            else:\n",
    "                print(itemN)\n",
    "    else:\n",
    "        print(item)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "그런데 프로그램을 이렇게 구현하면 안된다.\n",
    "만약에 영화목록이 4중, 5중으로 구성된 리스트로 작성되었다면\n",
    "위 프로그램은 4중, 5중 `for` 반복문으로 수정해야 하고,\n",
    "그러면서 프로그램의 길이와 복잡도가 기하급수적으로 증가하기 때문이다.\n",
    "\n",
    "처리해야 하는 데이터에 따라 프로그램이 수정되거나 복잡도가 증가하지 않는 \n",
    "프로그램을 구현해야 한다. \n",
    "\n",
    "다시 한 번 위 세 개의 프로그램을 살펴보자. \n",
    "세 개의 프로그램은 사실상 아래 명령문을 반복해서 사용한다. \n",
    "\n",
    "```python\n",
    "for 항목 in 리스트:\n",
    "    if isinstance(항목, list):\n",
    "        명령문\n",
    "    else:\n",
    "        print(항목)\n",
    "```\n",
    "\n",
    "위 명령문은 리스트의 항목이 또 다른 리스트이면 그 리스트의 항목들을 대상으로 동일한 확인작업을 수행하며,\n",
    "더 이상 리스트가 다른 리스트의 항목으로 포함되지 않을 때 까지 반복된다.\n",
    "즉, 모든 중첩 리스트가 해체될 까지 리스트 여부를 반복하며, \n",
    "리스트가 아니면 해당 항목을 화면에 출력한다.\n",
    "\n",
    "이런 반복작업을 **재귀**(recursion)라 부르며,\n",
    "반복되는 작업에 이름을 주면, 위 세 개의 코드를 하나의 함수로 정의할 수 있다.\n",
    "예를 들어, 아래와 같이 앞서 언급된 명령문에 `printItems`이란 이름을 주어 함수로 정의해보자."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "def printItems(aList):\n",
    "    for item in aList:\n",
    "        if isinstance(item, list):\n",
    "            printItems(item)\n",
    "        else:\n",
    "            print(item)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`printItems` 함수는 좀 이상하다. \n",
    "정의가 끝나지 않았는데 자신을 자신 본체에서 사용한다. \n",
    "(4번 줄 참조)\n",
    "\n",
    "실제로 `printItems` 함수를 호출하면 실행과정 중에\n",
    "자신을 또다시 호출한다. \n",
    "단, 사용되는 인자가 다르며, 애초에 사용된 리스트의 항목이면서\n",
    "또다른 리스트가 인자로 사용된다.\n",
    "이런 함수를 자기 자신을 호출한다는 의미로 **재귀함수**(recursive function)라 부른다. \n",
    "\n",
    "사실 임의로 중첩된 리스트를 인자로 받아도 중첩을 모두 풀어버린다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "기생충\n",
      "2019\n",
      "설국열차\n",
      "2013\n",
      "살인의 추억\n",
      "2003\n"
     ]
    }
   ],
   "source": [
    "printItems(moBong)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 예제: 콜라츠 추측"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "독일 수학자인 콜라츠(Collatz, L.)가 1937년에 아래 알고리즘을\n",
    "얼마나 많이 반복하면 최종적으로 숫자 1에 다다를 것인가를 질문했다.\n",
    "\n",
    "* 주어진 숫자가 짝수면 2로 나눈다.\n",
    "* 주어진 숫자가 홀수면 3배한 후 1을 더한다.\n",
    "\n",
    "실제로 숫자 7부터 시작해서 위 과정을 16번 반복하면 1에 다다른다. \n",
    "\n",
    "    7, 22, 11, 34, 17, 52, 26, 13, 40, 20, 10, 5, 16, 8, 4, 2, 1\n",
    "    \n",
    "반면에 숫자 128부터 시작하면 7번만 반복하면 된다.\n",
    "\n",
    "    128, 64, 32, 16, 8, 4, 2, 1\n",
    "    \n",
    "즉, 처음 시작하는 값이 작다고 해서 반드시 먼저 끝나는 것이 아니다.\n",
    "또한 무지 오랫동안 반복해야 하는 경우도 있다.\n",
    "예를 들어, 129로 시작하면 무려 122번 반복해야 한다.\n",
    "\n",
    "아래 그림은 10,000까지의 숫자들과 관련된 반복회수를 보여준다.\n",
    "그림에서 알 수 있듯이 반복회수와 관련된 수학적 특징을 확인하기 어렵다.\n",
    "실제로 콜라츠의 질문에 대한 답이 여전히 알려지지 않았다.\n",
    "반면에 무한 반복되는 경우도 알려지지 않았다.\n",
    "\n",
    "콜라츠는 어떤 숫자로 시작하든지 반복잡업이 언젠가는 끝난다고 추측하였지만,\n",
    "언제 끝나는가는 수학적으로 알아내지 못했으며, 여전히 미해결 문제로 남아 있다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>\n",
    "<table cellspacing=\"20\">\n",
    "<tr>\n",
    "<td>\n",
    "<img src=\"images/collatz01.png\">\n",
    "</td>\n",
    "</tr>\n",
    "</table>\n",
    "</p>\n",
    "\n",
    "<그림출처: [위키백과](https://en.wikipedia.org/wiki/Collatz_conjecture)>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "콜라츠의 질문에 답하는 함수를 아래와 같이 `while` 반복문을 이용하여 구현할 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "def collatzWhile(num):\n",
    "    count = 0\n",
    "    while (num != 1):\n",
    "        if num%2 == 0:\n",
    "            num = num//2\n",
    "        else:\n",
    "            num = num*3+1\n",
    "        count = count+1\n",
    "    return count"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "16"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "collatzWhile(7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "collatzWhile(128)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "121"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "collatzWhile(129)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "반면에 재귀를 이용할 경우 아래와 같이 구현한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "def collatz_(num):\n",
    "    if num == 1:\n",
    "        return 0\n",
    "    elif num%2 == 0:\n",
    "        return collatz_(num//2) + 1\n",
    "    else:\n",
    "        return collatz_(num*3 + 1) + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "16"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "collatz_(7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "collatz_(128)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "121"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "collatz_(129)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "반복되는 과정을 보고 싶으면 반복될 때마다 숫자를 출력하면 된다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "def collatzWhile_(num):\n",
    "    count = 0\n",
    "    while (num != 1):\n",
    "        if num%2 == 0:\n",
    "            print(num, end=', ')\n",
    "            num = num//2\n",
    "        else:\n",
    "            print(num, end=', ')\n",
    "            num = num*3+1\n",
    "        count = count+1\n",
    "    return count"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7, 22, 11, 34, 17, 52, 26, 13, 40, 20, 10, 5, 16, 8, 4, 2, "
     ]
    },
    {
     "data": {
      "text/plain": [
       "16"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "collatzWhile_(7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "128, 64, 32, 16, 8, 4, 2, "
     ]
    },
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "collatzWhile_(128)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "129, 388, 194, 97, 292, 146, 73, 220, 110, 55, 166, 83, 250, 125, 376, 188, 94, 47, 142, 71, 214, 107, 322, 161, 484, 242, 121, 364, 182, 91, 274, 137, 412, 206, 103, 310, 155, 466, 233, 700, 350, 175, 526, 263, 790, 395, 1186, 593, 1780, 890, 445, 1336, 668, 334, 167, 502, 251, 754, 377, 1132, 566, 283, 850, 425, 1276, 638, 319, 958, 479, 1438, 719, 2158, 1079, 3238, 1619, 4858, 2429, 7288, 3644, 1822, 911, 2734, 1367, 4102, 2051, 6154, 3077, 9232, 4616, 2308, 1154, 577, 1732, 866, 433, 1300, 650, 325, 976, 488, 244, 122, 61, 184, 92, 46, 23, 70, 35, 106, 53, 160, 80, 40, 20, 10, 5, 16, 8, 4, 2, "
     ]
    },
    {
     "data": {
      "text/plain": [
       "121"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "collatzWhile_(129)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "def collatz(num):\n",
    "    if num == 1:\n",
    "        print(num)\n",
    "        return 0\n",
    "    elif num%2 == 0:\n",
    "        print(num, end=', ')\n",
    "        return collatz(num//2) + 1\n",
    "    else:\n",
    "        print(num, end=', ')\n",
    "        return collatz(num*3 + 1) + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7, 22, 11, 34, 17, 52, 26, 13, 40, 20, 10, 5, 16, 8, 4, 2, 1\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "16"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "collatz(7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "128, 64, 32, 16, 8, 4, 2, 1\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "collatz(128)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "129, 388, 194, 97, 292, 146, 73, 220, 110, 55, 166, 83, 250, 125, 376, 188, 94, 47, 142, 71, 214, 107, 322, 161, 484, 242, 121, 364, 182, 91, 274, 137, 412, 206, 103, 310, 155, 466, 233, 700, 350, 175, 526, 263, 790, 395, 1186, 593, 1780, 890, 445, 1336, 668, 334, 167, 502, 251, 754, 377, 1132, 566, 283, 850, 425, 1276, 638, 319, 958, 479, 1438, 719, 2158, 1079, 3238, 1619, 4858, 2429, 7288, 3644, 1822, 911, 2734, 1367, 4102, 2051, 6154, 3077, 9232, 4616, 2308, 1154, 577, 1732, 866, 433, 1300, 650, 325, 976, 488, 244, 122, 61, 184, 92, 46, 23, 70, 35, 106, 53, 160, 80, 40, 20, 10, 5, 16, 8, 4, 2, 1\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "121"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "collatz(129)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 함수호출과 스택 다이어그램"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "함수를 호출하여 실행을 하면 컴퓨터 메모리의 스택(stack) 영역에 함수의 호출과 실행과정, \n",
    "그리고 실행 결과값과 관련된 정보의 변화가 일어난다. \n",
    "이런 정보의 변화를 **프레임**(frame)으로 다루며, \n",
    "프레임은 모든 함수와 변수의 생성, 호출, 삭제 과정을 기록한다.\n",
    "\n",
    "또한 하나의 함수가 호출될 때마다 하나의 프레임이 임시로 생성되었다가 함수의 실행이 종료되면 해당 함수의\n",
    "리턴값을 다른 프레임에 넘겨 준 후에 사라지는 과정이 반복된다. 이렇게 특정 함수호출과 관련된 프레임을 **지역 프레임**이라 \n",
    "부른다.\n",
    "반면에 프로그램이 실생되는 전 과정동안 살아 있는 프레임을 **전역 프레임**이라 부른다. \n",
    "\n",
    "예를 들어, 앞서 지역변수와 전역변수를 설명하면서 사용한 코드를 \n",
    "[PythonTutor:지역변수 전역변수](http://pythontutor.com/visualize.html#code=def%20hour_to_min%28hour%29%3A%0A%20%20%20%20minutes%20%3D%20hour%20*%2060%0A%20%20%20%20return%20minutes%0A%0Atwo_hour%20%3D%20hour_to_min%282%29%0Aprint%28minutes%29&cumulative=false&curInstr=0&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false)에서 \n",
    "실행하면서 프레임의 변화를 살펴볼 수 있다. \n",
    "\n",
    "위 프로그램을 한 단계씩 실행할 때 아래 사항들에 생각하면서 메모리 상태의 변화를 살펴보아야 한다. \n",
    "\n",
    "* 전역변수와 함수들은 전역 프레임(global frame)에서 다룬다.\n",
    "* 지역변수들은 함수가 호출되면 생성되어 지역변수들의 정보를 다루다가, 함수의 실행이 종료되면 \n",
    "    모든 정보와 함께 사라진다. \n",
    "    예를 들어, 마지막 그림에서 `minutes` 값을 확인하고자 할 때 오류가 발생하는 이유가 \n",
    "    `hour_to_min` 함수가 호출될 때 생성된 지역 프레임이 함수의 실행이 종료되면 사라지기 때문이라는 \n",
    "    점을 눈으로 확인할 수 있다.\n",
    "\n",
    "반면에 재귀함수의 실행과정 동안 많은 프레임의 생성과 소멸이 발생한다.\n",
    "그리고 이런 프레임들의 변화가 스택(stack) 형식으로 이루어지는데,\n",
    "따라서 그와 같은 프레임들의 변화를 **스택 다이어그램**(stack diagram)이라 부른다.\n",
    "\n",
    "에를 들어,\n",
    "[PythonTutor: 콜라츠 추측](http://pythontutor.com/visualize.html#code=def%20collatz%28num%29%3A%0A%20%20%20%20if%20num%20%3D%3D%201%3A%0A%20%20%20%20%20%20%20%20print%28num%29%0A%20%20%20%20%20%20%20%20return%200%0A%20%20%20%20elif%20num%252%20%3D%3D%200%3A%0A%20%20%20%20%20%20%20%20print%28num,%20end%3D',%20'%29%0A%20%20%20%20%20%20%20%20return%20collatz%28num//2%29%20%2B%201%0A%20%20%20%20else%3A%0A%20%20%20%20%20%20%20%20print%28num,%20end%3D',%20'%29%0A%20%20%20%20%20%20%20%20return%20collatz%28num*3%20%2B%201%29%20%2B%201%0A%20%20%20%20%20%20%20%20%0Acollatz%287%29&cumulative=false&curInstr=0&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false)에서\n",
    "재귀함수 호출 과정 동안 메모리에서 벌어지는 프레임의 생성과 소멸 과정,\n",
    "즉, 스택 다이어그램의 변화를 살펴볼 수 있다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 동적 타이핑 vs. 정적 타이핑"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "함수는 임의의 값을 인자로 받는다. \n",
    "하지만 함수마다 다룰 수 있는 값들의 자료형이 존재하며,\n",
    "다룰 수 없는 자료형의 값이 인자로 사용되면 오류가 발생한다.\n",
    "\n",
    "예를 들어, `type` 함수는 모든 자료형의 값을 다룰 수 있지만,\n",
    "`abs` 함수는 정수와 실수는 다루지만, 문자열을 \n",
    "인자로 사용하면 오류가 발생한다. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "bad operand type for abs(): 'str'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-55-472c41872a21>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mabs\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'-3.3'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: bad operand type for abs(): 'str'"
     ]
    }
   ],
   "source": [
    "abs('-3.3')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "이렇듯, 파이썬 함수는 임의의 값에 적용될 수 있지만,\n",
    "인자의 자료형을 파이썬 해석기가 파악해서 적용가능 여부를 판단한다.\n",
    "이런 기능을 **동적 타이핑**이라 부른다.\n",
    "즉, 처음부터 인자의 자료형을 지정하거나 확인하는 게 아니라\n",
    "프로그램을 실행하는 도중에 사용되는 함수 인자들의 자료형을 확인한다는 의미이다.\n",
    "이는 함수가 다루는 모든 값에 대해 동일하다. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 파이썬과 정적 타이핑"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "C, Java 등 많은 프로그래밍 언어는 동적 타이핑 대신에 **정적 타이핑**(static typing)을 지원한다.\n",
    "즉, 함수나 변수를 선언할 때 사용되는 변수들의 자료형과 인자 및 반환값의 자료형을 \n",
    "애초부터 명시해야 하며 지정된 자료형이 사용되지 않을 경우 오류를 발생시킨다.\n",
    "\n",
    "파이썬은 3.6 버전부터 정적 타이핑 형식을 지원한다. \n",
    "다만 C, Java의 자료형과 관련된 엄격함은 전혀 존재하지 않으며, \n",
    "그냥 정적 타이핑의 형식만 빌려왔다.\n",
    "\n",
    "즉, **자료형 명시**(type annotations)를 지원할 뿐이며, \n",
    "실제로는 동적 타이핑 형식으로 문법과 실행 과정을 확인하고 제어한다.\n",
    "\n",
    "예를 들어, `myAdd` 함수를 아래와 같이 선언할 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "def myAdd(a: float, b: float) -> float:\n",
    "    return a + b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`myAdd` 함수는 부동소수점의 합을 계산함수라는 의도를 \n",
    "명확히 하기 위해 `float`라는 자료형을 입력값와 리턴값에 대해 명시하였다.\n",
    "\n",
    "그래서 위 함수는 마치 부동소수점에 대해서만 작동하는 것처럼 보인다.\n",
    "하지만 이는 `myAdd` 함수는 여전히 다른 자료형의 값들을 \n",
    "인자로 사용할 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15\n",
      "[1, 2, 3]\n",
      "저 잠깐만요!\n"
     ]
    }
   ],
   "source": [
    "print(myAdd(10, 5))\n",
    "print(myAdd([1, 2], [3]))\n",
    "print(myAdd(\"저 \", \"잠깐만요!\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "즉, 자료형의 명시는 함수 정의의 의도를 전달하는 역할만 수행하며,\n",
    "파이썬이 정적타이피을 지원한다는 의미는 아님에 주의해야 한다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 연습문제"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. 다음 조건을 만족시키는 `right_justify`라는 함수를 정의하라.\n",
    "    * 인자는 하나만 받으며, 매개변수는 `s`라 부른다.\n",
    "    * 문자열 하나를 인자로 받아 실행하면 해당 문자열의 끝이 70번째 칸에 위치하도록 \n",
    "        입력받은 문자열 앞에 충분한 공백이 위치하도록 출력(print)한다. \n",
    "```python\n",
    ">>> right_justify('monty')\n",
    "                                                                monty\n",
    "```                                                                 \n",
    "    힌트: 문자열 결합 및 반복, 그리고 문자열의 길이를 되돌려주는 내장함수 `len` 활용 가능.\n",
    "<br><br>\n",
    "1. 파이썬은 정의된 함수도 하나의 값으로 취급한다. \n",
    "    따라서 함수를 다른 함수의 인자로 사용하거나 변수에 할당되는 값으로 사용될 수 있다. \n",
    "    예를 들어, 아래에 정의된 `do_twice` 함수는 함수 `f`를 인자로 입력받으면\n",
    "    그 함수를 두 번 호출하여 실행하도록 하는 함수이다. \n",
    "```python\n",
    "def do_twice(f):\n",
    "    f()\n",
    "    f()\n",
    "```\n",
    "    그리고 `print_spam` 이라는 함수를 두 번 호출하도록 `do_twice`를 활용하고자 하면 \n",
    "    아래와 같이 프로그램을 작성하면 된다.\n",
    "    ```python\n",
    "    def print_spam():\n",
    "        print('spam')\n",
    "\n",
    "    do_twice(print_spam)\n",
    "    ```\n",
    "    1. 이 프로그램을 직접 입력해서 실행해 보라.\n",
    "    1. 아래 조건을 만족하도록 `do_twice` 함수를 수정하라. \n",
    "        * 두 개의 인자를 사용한다.\n",
    "        * 첫째 매개변수는 하나의 인자를 받는 함수를 인자로 입력받는다.\n",
    "        * 둘째 매개변수는 첫째 인자에 사용된 함수의 인자로 사용될 수 있는 값을 인자로 입력받는다.\n",
    "        * 첫째 인자로 사용된 함수를 둘째 인자로 사용된 값을 이용하여 두 번 연속 호출한다. \n",
    "    1. 아래 조건을 만족하도록 `do_four` 함수를 수정하라. \n",
    "        * 두 개의 인자를 사용한다.\n",
    "        * 첫째 매개변수는 하나의 인자를 받는 함수를 인자로 입력받는다.\n",
    "        * 둘째 매개변수는 첫째 인자에 사용된 함수의 인자로 사용될 수 있는 값을 인자로 입력받는다.\n",
    "        * 첫째 인자로 사용된 함수를 둘째 인자로 사용된 값을 이용하여 네 번 연속 호출한다. \n",
    "        * 앞서 정의된 `do_twice` 함수를 반드시 활용한다.\n",
    "<br><br>\n",
    "답: http://greenteapress.com/thinkpython2/code/do_four.py\n",
    "<br><br>\n",
    "1. 이번 문제는 지금까지 배운 내용을로 풀 수 있다. \n",
    "    1. 다음과 같은 격자를 그리는 함수를 작성하라.\n",
    "        ```\n",
    "        + - - - - + - - - - +\n",
    "        |         |         |\n",
    "        |         |         |\n",
    "        |         |         |\n",
    "        |         |         |\n",
    "        + - - - - + - - - - +\n",
    "        |         |         |\n",
    "        |         |         |\n",
    "        |         |         |\n",
    "        |         |         |\n",
    "        + - - - - + - - - - +\n",
    "        ```\n",
    "        힌트: 한 줄에 하나 이상의 값을 출력하려면 `print` 함수에 여러 인자를 사용하면 된다.\n",
    "        ```python\n",
    "        print('+', '-')\n",
    "        ```\n",
    "        `print` 함수는 기본적으로 줄바꿈을 실행한다.\n",
    "        줄바꿈을 하지 않기 위해서는 에를 들어 아래와 같이 실행하면 된다.\n",
    "        ```\n",
    "        print('+', end=' ')\n",
    "        print('-')\n",
    "        ```\n",
    "        위 프로그램을 실행하면 `+ -` 형식으로 출력된다. \n",
    "        <br><br>\n",
    "    1. 4개의 행과 4개의 열을 갖는 격자를 그리는 함수를 작성하라.\n",
    "\n",
    "    답: http://greenteapress.com/thinkpython2/code/grid.py\n",
    "    <br><br>\n",
    "    이 연습문제는 아래 책의 Oualline에 포함된 연습문제를 응용하였다. \n",
    "    \n",
    "            Practical C Programming, Third Edition, O’Reilly Media, 1997.\n",
    "\n",
    "    1. 위 함수를 일반화 하라. 즉, 입력값 n이 주어지면\n",
    "        n개의 행과 n개의 열을 갖는 격자를 그리는 함수를 작성하라.\n",
    "        <br><br>\n",
    "\n",
    "1. `printItems` 수정하여 `moBong`에 포함된 항목들을 아래와 같이 \n",
    "    출력하도록 하는 `printItems2` 함수를 구현하라.\n",
    "\n",
    "        기생충\n",
    "        2019\n",
    "            설국열차\n",
    "            2013\n",
    "                살인의 추억\n",
    "                2003\n",
    "\n",
    "    **힌트**\n",
    "    * `printItems` 함수의 인자를 두 개로 수정한다. \n",
    "        하나는 리스트의 인자를 다루며, 다른 하나는 들어쓰기 정도를 다루는 \n",
    "        인자를 하나 받는다.\n",
    "        \n",
    "        ```python\n",
    "        def printItems2(aList, level):\n",
    "        명령문\n",
    "        ```\n",
    "\n",
    "    * 위에서 `level` 매개변수의 인자는 탭키를 사용하는 횟수를 나타내도록 한다. \n",
    "        그러면 `printItems2(moBong, 0)`을 실행하면 원하는 결과가 나와야 한다.\n",
    "    * 탭 출력은 `print('\\t')`를 이용하면 된다.\n",
    "    <br><br>\n",
    "1. 위 과제에서 구현한 `printItems2` 함수를 아래와 같이 수정하라.\n",
    "    * 인자수를 세 개로 늘린다.\n",
    "\n",
    "        ```python\n",
    "        def printItems3(aList, level, indent=False):\n",
    "            명령문\n",
    "        ```\n",
    "\n",
    "    * `indent` 매개변수의 옵션인자 값이 `True`이면 연습4에서 처럼 들여쓰기를 하고, \n",
    "        `False`이면 들여쓰기를 하지 않아야 한다.\n",
    "    <br><br>\n",
    "1. `printItems` 함수를 재귀가 아닌 `while` 함수를 이용하여 구현하라.\n",
    "\n",
    "    **힌트:** `while` 반복문에 사용되는 조건식을 선택하는 게 핵심이다.\n",
    "    재귀로 구현된 함수로부터 이에대한 힌트를 얻을 수 있다."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}