02.02 부동소수점 실수 자료형.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "school_cell_uuid": "9c471a39614943db981ebd0c6e2a1a1a"
   },
   "source": [
    "# 2.2 부동소수점 실수 자료형"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "school_cell_uuid": "9b147e7d91da47c2b7dcb38c996b0430"
   },
   "source": [
    "## 정수와 실수 자료형"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```{margin}\n",
    "정수(integer)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```{margin}\n",
    "실수(real number)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "school_cell_uuid": "a77d172f2c984fbfa1a9e4d368a6d033"
   },
   "source": [
    "파이썬에서는 정수(integer)뿐 아니라 소숫점을 포함하는 실수(real number)도 다룰 수 있다. \n",
    "정수 데이터에는 소숫점이 없고 실수 데이터에는 소수점이 붙어 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "school_cell_uuid": "941dfff1812140bcab0b2605a711346e"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10  # 정수"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10.0"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10.0  # 실수"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "정수부가 0인 실수는 0을 생략할 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "school_cell_uuid": "a01a7f5609394b29ab13c4fb57bcd8a9"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.1"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    ".1  # .1 = 0.1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "숫자 계산을 하는 경우 계산에 쓰인 숫자 중 하나라도 소숫점이 있는 실수가 있으면 계산결과는 실수가 된다. 나눗셈 연산의 결과는 입력에 상관없이 항상 실수로 처리한다. 예를 들어 $10 \\times 5$는 정수로 취급하지만 $10.0 \\times 5$나 $10 \\div 5$는 실수로 취급한다. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "school_cell_uuid": "b7305e070348408f8e99a55161add9c3"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "50"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10 * 5  # 정수"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "50.0"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10.0 * 5  # 실수"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.0"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10 / 5  # 실수"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```{margin}\n",
    "부동소수점(floating point number)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```{margin}\n",
    "`int`\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```{margin}\n",
    "`float`\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```{margin}\n",
    "`type`\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "school_cell_uuid": "db56c335ecca4256bbbdb46705955d40"
   },
   "source": [
    "정수와 실수는 컴퓨터 메모리에 저장되는 방식이 다르다. 이를 데이터의 자료형(type)이 다르다고 한다. 파이썬에서 정수는 `int`라는 정수 자료형으로 처리한다. 실수는 `float`라는 부동소수점(floating point number) 자료형으로 처리된다. 파이썬에서 데이터의 자료형을 알려면 `type` 명령을 사용한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "school_cell_uuid": "328b06ca8fad4a9b9a2fa7f7cc9251a8"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "school_cell_uuid": "0718a8677d994fe7bd880bc0362bfc93"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(10.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "school_cell_uuid": "d9e0e53f309e4487957f963ef6dad098"
   },
   "source": [
    "## 부동소수점 실수"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "school_cell_uuid": "72af3d6d76c848d89e744c195ed7f295"
   },
   "source": [
    "프로그래밍 언어는 IEEE 754라는 국제표준에 따라 실수를 부동소수점 방식으로 표현한다. 부동소수점 방식에서는 숫자를 정수로 된 유효숫자와 정수로 된 지수의 곱으로 표현한다. 예를 들어 \n",
    "십진수 부동소수점 방식에서 $123.456$이란 숫자는 $123456 \\times 10^{-3}$ 이므로 $123456$이라는 정수 유효숫자와 $-3$이라는 정수 지수로 나타낼 수 있다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "school_cell_uuid": "af9cd89f561d4abea02934d430773705"
   },
   "source": [
    "파이썬에서는 ``유효숫자e지수`` 라는 방법으로 부동소수점 형태를 직접 표현한다.\n",
    "\n",
    "$$ \\text{유효숫자}e\\text{지수} = \\text{유효숫자} \\times 10^{\\text{지수}} $$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "school_cell_uuid": "7ca75c54535a4b4995810f851bd7bb5b"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12300.0"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "123e2  # 123e2 = 123.0 x 100 = 12300.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "school_cell_uuid": "3a87ab29344c45978ad610094745955f"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.23"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "123e-2  # 123e-2 = 123.0 x 0.01 = 1.23"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "school_cell_uuid": "da8a56049c014c0dbcbfc56dc7c5edbe"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.123456"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "123.456e-3  # 123.456e-3 = 123.456 x 0.001 = 0.123456"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "bootstrap": {
     "panel": {
      "class": "panel-default"
     }
    }
   },
   "source": [
    "```{admonition} 연습 문제 2.2.1\n",
    "\n",
    "``유효숫자e지수`` 표현법으로 되어 있는 다음 숫자를 보통의 소숫점 표현으로 나타내라.\n",
    "\n",
    "1. 5e8\n",
    "2. 5.6e3\n",
    "3. -2.1e2\n",
    "4. -3.4e-1\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "bootstrap": {
     "panel": {
      "class": "panel-default"
     }
    }
   },
   "source": [
    "```{admonition} 연습 문제 2.2.2\n",
    "\n",
    "다음 숫자를 ``유효숫자e지수`` 표현법으로 나타내라. 유효숫자는 정수가 되어야 한다.\n",
    "\n",
    "1. 3.141592\n",
    "1. 2.718\n",
    "1. 1.4\n",
    "1. 1.73\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 십진법과 이진법"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "컴퓨터는 십진법이 아닌 이진법을 사용한다. 십진법에서는 0, 1, 2, 3, 4, 5, 6, 7, 8, 9의 10개 숫자만 사용하고 10 이상의 수는 $10, 100, 1000, 10000, \\ldots$ 자리를 나타내는 숫자를 나열하여 표현한다. 따라서 모든 십진법 숫자는 10의 제곱의 합으로 풀어서 나타낼 수 있다.\n",
    "\n",
    "$$ \n",
    "\\begin{eqnarray}\n",
    " 12 &=&     & & 10 &+& 2 &=&               & & 1 \\times 10^1 &+& 2 \\times 10^0 \\\\\n",
    "123 &=& 100 &+& 20 &+& 3 &=& 1 \\times 10^2 &+& 2 \\times 10^1 &+& 3 \\times 10^0 \\\\\n",
    "\\end{eqnarray}\n",
    "$$\n",
    "\n",
    "소수점이 있는 경우에는 소수점 아래의 숫자가 $10^{-1}, 10^{-2}, 10^{-3}, \\ldots$ 자리를 나타내는 숫자이다. \n",
    "\n",
    "$$ \n",
    "\\begin{eqnarray}\n",
    " 1.2  &=& 1 + 0.2                &=&   1 \\times 10^0 &+& 2 \\times 10^{-1} \\\\\n",
    "1.123 &=& 1 + 0.1 + 0.02 + 0.003 &=&   1 \\times 10^0 &+& 1 \\times 10^{-1} &+& 2 \\times 10^{-2} + 3 \\times 10^{-3} \\\\\n",
    "\\end{eqnarray}\n",
    "$$\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "bootstrap": {
     "panel": {
      "class": "panel-default"
     }
    }
   },
   "source": [
    "```{admonition} 연습 문제 2.2.3\n",
    "\n",
    "다음 십진법 숫자를 10의 제곱의 합으로 풀어서 나타내라.\n",
    "\n",
    "1. 1234\n",
    "1. 1010\n",
    "1. 3.14\n",
    "1. 0.023\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "이진법에서는 0, 1의 2개 숫자만 사용하고 2 이상의 수는 $2, 4, 8, 16, 32, \\ldots$ 자리를 나타내는 숫자를 나열하여 표현한다.\n",
    "\n",
    "$$ \n",
    "\\begin{eqnarray}\n",
    " 1 &=&              & &              & &              & & 1 \\times 2^0 &=& 1_{(2)} \\\\\n",
    " 2 &=&              & &              & & 2 \\times 2^1 &+& 0 \\times 2^0 &=& 10_{(2)} \\\\\n",
    " 3 &=&              & &              & & 1 \\times 2^1 &+& 1 \\times 2^0 &=& 11_{(2)} \\\\\n",
    " 4 &=&              & & 1 \\times 2^2 &+& 0 \\times 2^1 &+& 0 \\times 2^0 &=& 100_{(2)} \\\\\n",
    " 5 &=&              & & 1 \\times 2^2 &+& 0 \\times 2^1 &+& 1 \\times 2^0 &=& 101_{(2)} \\\\\n",
    "15 &=& 1 \\times 2^3 &+& 1 \\times 2^2 &+& 1 \\times 2^1 &+& 1 \\times 2^0 &=& 1111_{(2)}  \\\\\n",
    "\\end{eqnarray}\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```{margin}\n",
    "`bin`\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "파이썬의 `bin` 명령을 쓰면 정수인 십진수를 이진수로 변환할 수 있다. 이진수는 숫자 앞에 `0b`라는 접두사가 붙는다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'0b11'"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bin(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'0b1111'"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bin(15)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "소수점이 있는 경우에도 다음처럼 풀어서 나타낼 수 있다.\n",
    "\n",
    "$$ \n",
    "\\begin{eqnarray}\n",
    " 0.5   &=& 1 \\times 2^{-1} & &                 & &                 &=& 0.1_{(2)} \\\\\n",
    " 0.25  &=& 0 \\times 2^{-1} &+& 1 \\times 2^{-2} & &                 &=& 0.01_{(2)} \\\\\n",
    " 0.125 &=& 0 \\times 2^{-1} &+& 0 \\times 2^{-2} &+& 1 \\times 2^{-3} &=& 0.001_{(2)} \\\\\n",
    " 0.75  &=& 1 \\times 2^{-1} &+& 1 \\times 2^{-2} & &                 &=& 0.11_{(2)} \\\\\n",
    " 0.375 &=& 0 \\times 2^{-1} &+& 1 \\times 2^{-2} &+& 1 \\times 2^{-3} &=& 0.011_{(2)} \\\\\n",
    " 0.875 &=& 1 \\times 2^{-1} &+& 1 \\times 2^{-2} &+& 1 \\times 2^{-3} &=& 0.111_{(2)} \\\\\n",
    "\\end{eqnarray}\n",
    "$$\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "bootstrap": {
     "panel": {
      "class": "panel-default"
     }
    }
   },
   "source": [
    "```{admonition} 연습 문제 2.2.4\n",
    "\n",
    "다음 이진법 숫자를 2의 제곱의 합으로 풀어서 나타내라.\n",
    "\n",
    "1. 13\n",
    "1. 129\n",
    "1. 0.8\n",
    "1. 1.25\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 부동소수점 오차"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "school_cell_uuid": "636908168b3541d990315b50c743dde8"
   },
   "source": [
    "1보다 작은 수의 경우에는 십진법으로 간단히 표현되는 수도 이진법에서는 무한개의 유효숫자를 가질 수 있다. 예를 들어 $0.1$이라는 숫자는 십진수로는 간단히 표현되지만 이진수로 나타내면 다음과 같이 $0011_{(2)}$이 무한히 반복되는 실수가 된다.\n",
    "\n",
    "$$ 0.1 = 0.00011001100110011001100110011001100110011001100110011001100110011\\cdots_{(2)} $$\n",
    "\n",
    "그런데 컴퓨터에서는 하나의 숫자를 나타내기 위한 메모리 크기가 제한되어 있어서 특정 소수점 이하는 생략하고 가장 비슷한 숫자로 표현할 수 밖에 없다. $0.1$은 실제로는 가장 비슷한 다음과 같은 숫자로 저장된다.\n",
    "\n",
    "$$ 0.1 \\approx 0.1000000000000000055511151231257827021181583404541015625 $$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "school_cell_uuid": "73027ca84edf465e90e5b3171e98929e"
   },
   "source": [
    "그런데 파이썬 콘솔이나 주피터 노트북에서 0.1을 입력하면 다음과 같이 그냥 0.1로 나타난다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "school_cell_uuid": "c7e4456980074487b8193e5b93d408db"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.1"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "0.1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```{margin}\n",
    "`%precision`\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "school_cell_uuid": "a5ce8060c26641be8792fd42666bf580"
   },
   "source": [
    "그 이유는 파이썬 콘솔이나 주피터 노트북과 같은 REPL 인터페이스에서 값이 출력될 때는 편의상 일정 소수점 이하를 생략하고 보여주기 때문이다. 만약 소수점 이하 55자리까지 보고 싶으면 `%precision` 매직(magic) 명령어를 사용한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "school_cell_uuid": "6c190a8177b942c6900020c342d83cba"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'%.55f'"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 소숫점 55자리까지 표현\n",
    "%precision 55   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "이 상태에서 다시 0.1이라고 입력하면 55자리까지의 유효숫자를 보여준다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "school_cell_uuid": "6bee00a964534af39a343bba3d21dea8"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.1000000000000000055511151231257827021181583404541015625"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "0.1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "school_cell_uuid": "9588b468d3044ed58adb80d9996e6ef5"
   },
   "source": [
    "다시 원래대로 돌아가려면 다음과 같이 입력한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "school_cell_uuid": "5b802616c7f6412da335ef586d44cf82"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'%r'"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%precision %r"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "school_cell_uuid": "4e711b59cd224d3fa0d730a31be21ac0"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.1"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "0.1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "school_cell_uuid": "f2f133ad098e414aa5c186aa98678168"
   },
   "source": [
    "이처럼 컴퓨터에서 실수를 계산할 때는 항상 미세한 오차를 가질 수 있으므로 실수의 계산을 할 때는 주의해야 한다. 예를 들어 $0.1+0.2=0.3$ 이지만 파이썬에서 비교하면 다음처럼 양변이 다르다는 결과를 보인다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "school_cell_uuid": "c05cce1da88846e0b5f7f9ca7e45160a"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "0.1 + 0.2 == 0.3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "school_cell_uuid": "3fb56b8855e94e17b849b30a04077f7c"
   },
   "source": [
    "실제로 계산 결과를 보면 그 이유를 알 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "school_cell_uuid": "99c11bbf699a4ddfacce876c15ea803f"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.30000000000000004"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "0.1 + 0.2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "school_cell_uuid": "0010d28de99b4f33a58c1defe77ded40"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'%.55f'"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%precision 55"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "school_cell_uuid": "76f5d84186e34863ac6d3d976139dc78",
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.2999999999999999888977697537484345957636833190917968750"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "0.3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "school_cell_uuid": "ca7c1f45f58041a38d250481d074edf0"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'%r'"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%precision %r"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```{margin}\n",
    "`round`\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "school_cell_uuid": "f1fc8163349741dd9a438ed9620d640b"
   },
   "source": [
    "따라서 실수를 비교할 때는 다음과 같이 `round` 명령을 사용하여 유효숫자를 지정한 반올림을 한 후에 비교해야 한다. `round` 명령은 두 번째 인수로 반올림할 소수점 이하의 유효숫자의 개수를 받는다. 다음 명령은 소수점 5자리까지 비교한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "school_cell_uuid": "39ed0cc7f9714addaf1246599acf9bbc"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "round(0.1 + 0.2, 5) == round(0.3, 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "school_cell_uuid": "fadc584840264fdc8997cf59fba2cd4a"
   },
   "source": [
    "또는"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "school_cell_uuid": "ee54006326f04afc94d02669ca92018f"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "round((0.1 + 0.2) - 0.3, 5) == 0.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "school_cell_uuid": "27dc018925764021aa916f1a3db25959"
   },
   "source": [
    "## 자료형 변환"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "school_cell_uuid": "16ec06ebcf3743f6bb437fedcaee408b"
   },
   "source": [
    "실수를 정수로 변환하거나 정수를 실수로 변환하려면 `int` 명령과 `float` 명령을 사용한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "school_cell_uuid": "d0920bc5bc5343ea9841c3dd4f113b3a"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int(1.0)  # 실수를 정수로 변환"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "school_cell_uuid": "5c9d2595e6c64cac9c2d8f112f821aee"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "float(1)  # 정수를 실수로 변환"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "school_cell_uuid": "31654d37e71144b09c675be11c67631f"
   },
   "source": [
    "만약 정수형으로 변환하려는 숫자가 정확히 정수로 표현될 수 없으면 소숫점 이하의 숫자를 버린다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "school_cell_uuid": "c048f0c1438b41039251c3881314e747"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int(3.14)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "school_cell_uuid": "dccd077801534fc3998ad53ef35fbad3"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int(3.9)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "school_cell_uuid": "dccd077801534fc3998ad53ef35fbad3"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-3"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int(-3.9)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "school_cell_uuid": "3607e13ba60c40ca9fc4ebe2188b6ac1"
   },
   "source": [
    "## `NaN`과 `Inf`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```{margin}\n",
    "`NaN`\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```{margin}\n",
    "`Inf`\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "school_cell_uuid": "0d45af333a674f4f89f28474867c6a57"
   },
   "source": [
    "IEEE 754 표준에 따른 부동소수점 자료형은 특별한 두 가지 값을 표현할 수 있다. 하나가 NaN(Not a Number)이고 또 하나는 Inf(Infinity)이다. NaN는 “숫자가 아닌 것”,  Inf는 “무한대”를 뜻한다. 파이썬에서는 다음과 같은 명령으로 표현한다. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "school_cell_uuid": "6ec33e426c5f462f86a2243697cf88a1"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "nan"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "float(\"NaN\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "school_cell_uuid": "26d3a10ca37746709572f688bd4d91ec"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "inf"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "float(\"Inf\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-inf"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "float(\"-Inf\")"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Edit 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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}