python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "312ec75e",
   "metadata": {},
   "source": [
    "# 파이썬 기초 배워보기\n",
    "\n",
    "이번 장에서는 변수와 상수, 데이터의 타입, 제어문, 함수 등 기본적인 파이썬 문법과 패키지를 사용하는 방법에 대해 살펴보도록 하겠다.\n",
    "\n",
    "## 상수와 변수\n",
    "\n",
    "프로그래밍의 가장 기본은 **상수**와 **변수**이다. 먼저 아래의 코드를 실행해보자."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "c77df616",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "var = 10\n",
    "print(var)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "df913cf9",
   "metadata": {},
   "source": [
    "10 이라는 숫자 혹은 문자와 같은 값 자체를 상수(constant)라고 한다. 반면 이러한 상수가 저장된 공간인 var는 변수(variable)라고 한다. `var = 10`은 var라는 변수에 10을 할당(저장)하라는 의미다. `print()`는 결과물을 출력하는 함수로써, var의 내용을 출력한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "f225dfb3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World\n"
     ]
    }
   ],
   "source": [
    "var = 'Hello World'\n",
    "print(var)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "de32a0ac",
   "metadata": {},
   "source": [
    "var라는 변수에 새롭게 'Hellow World'라는 상수(문자)를 입력하였더니 그 값이 바뀌었다. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "959b481b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "var1 = 1\n",
    "var2 = 2\n",
    "\n",
    "print(var1 + var2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "80087eb7",
   "metadata": {},
   "source": [
    "var1이라는 변수에는 1이라는 숫자가, var2이라는 변수에는 2라는 숫자를 입력하였다. `var1 + var2`는 1+2와 같으므로 3이라는 결과가 출력된다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "4086084a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "var1 = 3\n",
    "print(var1 + var2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c307e144",
   "metadata": {},
   "source": [
    "var1이라는 변수에 다시 3이라는 숫자를 입력하면 `var1 + var2`는 3+2가 되므로 5라는 결과가 출력된다. 이처럼 변수에는 계속해서 다른 상수를 입력할 수 있다.\n",
    "\n",
    "## 데이터 타입\n",
    "\n",
    "파이썬에는 다양한 데이터 타입이 존재하며, 이에 대해 하나씩 알아보도록 하자.\n",
    "\n",
    "### 숫자형\n",
    "\n",
    "숫자형(Number)은 정수나 실수와 같이 숫자 형태로 이루어진 데이터 타입이다. (8진수나 16진수도 있으나 거의 사용하지 않는다).\n",
    "\n",
    "먼저 정수형(Integer)이란 -2, -1, 0, 1, 2처럼 소수점을 사용하지 않고 숫자를 표현한 것이다. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "b5e72cd4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "383bd4dc",
   "metadata": {},
   "source": [
    "`type()` 함수는 데이터 타입을 확인해주는 역할을 한다. 1이라는 숫자의 타입을 확인해보면 int, 즉 정수임을 알 수 있다. 한편 실수형(Floating-point)이란 소수점이 포함된 숫자다. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "5d7e5f77",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(1.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fe933082",
   "metadata": {},
   "source": [
    "1.0이라는 숫자의 타입을 확인해보면 float, 즉 실수임을 알 수 있다. 일반적으로 1과 1.0은 동일한 숫자라고 생각할 수 있지만, 프로그래밍에서 정수형과 실수형은 엄밀하게는 다른 타입이다. \n",
    "\n",
    "#### 숫자형 연산하기\n",
    "\n",
    "숫자형은 다양한 연산이 가능하다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "fa3db626",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "print(2 + 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "837ff6ca",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "print(2 - 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "28428f0c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n"
     ]
    }
   ],
   "source": [
    "print(2 * 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "1c8a3ffb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.0\n"
     ]
    }
   ],
   "source": [
    "print(6 / 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3bbf5e35",
   "metadata": {},
   "source": [
    "파이썬에서는 기본적인 사칙연산(+, -, *, /)을 쉽게 할 수 있다. 이 외에도 다양한 연산자가 존재한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "21289a33",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3 ** 2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8f6eb20e",
   "metadata": {},
   "source": [
    "연산자 `**` 는 제곱을 의미한다. 즉 `3**2`는 $3^2$ 을 의미한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "8507ed68",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "7 // 3"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0de0f848",
   "metadata": {},
   "source": [
    "연산자 `//`는 나눗셈의 몫을 반환한다. 7을 3으로 나누면 몫은 2가 된다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "923cc94c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "7 % 3"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "57535311",
   "metadata": {},
   "source": [
    "연산자 `%`는 나눗셈의 나머지를 반환한다. 7을 3으로 나누면 몫은 2가 되며 나머지는 1이 된다.\n",
    "\n",
    "### 문자열\n",
    "\n",
    "문자열(String)이란 문자, 단어 등으로 구성된 문자들의 집합을 의미한다. 파이썬에서 문자열을 만드는 방법은 총 4가지가 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d4cd1bf8",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "\"Hello World\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2190f100",
   "metadata": {},
   "source": [
    "먼저 큰 따옴표(\")로 양쪽을 둘러싸서 문자열을 만들 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6bc53a96",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "'Hello World'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cbd048f1",
   "metadata": {},
   "source": [
    "따옴표(')로 양쪽을 둘러싸서도 문자열을 만들 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "18f4a875",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "\"\"\"퀀트 투자 포트폴리오 만들기\"\"\"\n",
    "'''퀀트 투자 포트폴리오 만들기'''"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "489d5112",
   "metadata": {},
   "source": [
    "큰 따옴표 3개를 연속(\"\"\")으로 양쪽을 둘러싸거나, 작은 따옴표 3개를 연속(''')으로 써서 양쪽을 둘러싸서도 문자열을 만들 수 있다. 따옴표를 3개 사용할 경우 줄 바꿈을 통해 여러줄의 문자열을 만들 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "c263241e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Life is too short\n",
      "You need python\n"
     ]
    }
   ],
   "source": [
    "multiline = \"\"\"Life is too short\n",
    "You need python\"\"\"\n",
    "\n",
    "print(multiline)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3813a079",
   "metadata": {},
   "source": [
    "파이썬에서는 문자열도 더하거나 곱할 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "84a696fb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello World'"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = 'Hello'\n",
    "b = ' World'\n",
    "\n",
    "a + b"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1eae6f9b",
   "metadata": {},
   "source": [
    "a라는 변수에 'Hello'라는 글자를, b라는 변수에 ' World'라는 글자를 입력한 후 두 변수를 더하면 두 글자가 합쳐진다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "306a1d35",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'QuantQuantQuant'"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c = 'Quant'\n",
    "\n",
    "c * 3"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a705ebc3",
   "metadata": {},
   "source": [
    "이번에는 c라는 변수에 'Quant'를 입력한 후 3을 곱하면, c가 세 번 반복된다.\n",
    "\n",
    "#### f-string 포매팅\n",
    "\n",
    "문자열에서 특정 부분만이 바뀌고 나머지 부분은 일정할 경우, 파이썬에서는 f-string 포매팅을 이용해 매우 쉽게 나타낼 수 있다. (해당 기능은 파이썬 3.6 버전 이상부터 사용이 가능하다.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "b3e55e31",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'나의 이름은 이현열이며, 1987년에 태어났습니다.'"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "name = '이현열'\n",
    "birth = '1987'\n",
    "\n",
    "f'나의 이름은 {name}이며, {birth}년에 태어났습니다.'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3ca75d27",
   "metadata": {},
   "source": [
    "f-string의 형태는 `f'문자열 {변수} 문자열'` 이다. 즉 문자열 맨 앞에 f를 붙이면 f-string 포매팅이 선언되며, 중괄호 안에 변수를 넣으면 해당 부분에 변수의 값이 입력된다.\n",
    "\n",
    "#### 문자열 길이 구하기\n",
    "\n",
    "문자열의 길이를 구할때는 `len()` 함수가 사용된다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "b93980f3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "17"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = 'Life is too short'\n",
    "len(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f27c402b",
   "metadata": {},
   "source": [
    "'Life is too short'이라는 문장은 빈 칸을 포함하여 총 17 글자로 이루어져 있다.\n",
    "\n",
    "#### 문자열 치환하기\n",
    "\n",
    "특정한 문자를 다른 문자로 바꾸는데는 `replace()` 함수가 사용된다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "bf18259f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'퀀트_투자_포트폴리오_만들기'"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "var = '퀀트 투자 포트폴리오 만들기'\n",
    "var.replace(' ', '_')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0c00c997",
   "metadata": {},
   "source": [
    "먼저 var 변수에 '퀀트 투자 포트폴리오 만들기'라는 문자열을 입력했다. 그 후 `문자열.replace(a, b)` 메서드를 사용하면 문자열에서 a라는 문자를 b라는 문자로 바꿀 수 있다. 즉 ' '는 공백을 의미하여, 이러한 공백을 모두 밑줄(_)로 변경하였다.\n",
    "\n",
    "#### 문자열 나누기\n",
    "\n",
    "`split()` 메서드를 이용하면 문자열을 나눌 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "a4ee6ee2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['퀀트', '투자', '포트폴리오', '만들기']"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "var = '퀀트 투자 포트폴리오 만들기'\n",
    "var.split(' ')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7df4b84f",
   "metadata": {},
   "source": [
    "`split()` 메서드 내부에 값을 입력하면, 해당 값을 기준으로 문자열을 나눠준다. 위 예제에서는 공백(' ')을 기준으로 각각의 단어를 나누었다.\n",
    "\n",
    "#### 문자열 인덱싱과 슬라이싱\n",
    "\n",
    "인덱싱(Indexing)이란 문자열 중 특정 위치의 값을 가져오는 것이며, 슬라이싱(Slicing)이란 특정 위치가 아닌 범위에 해당하는 문자열을 가지고 오는 것이다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "fe9dc94a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'a'"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "var = 'Quant'\n",
    "\n",
    "var[2]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cee9c923",
   "metadata": {},
   "source": [
    "인덱싱과 슬라이싱은 대괄호([ ])를 사용해서 표현한다. `var[2]`란 두번째 문자를 의미하며, 이에 해당하는 'a'이 출력되었다. **참고로 파이썬은 숫자를 1이 아닌 0부터 세므로** 'Quant'에서 Q는 `var[0]`, u는 `var[1]`, a는 `var[2]`에 해당한다.\n",
    "\n",
    "```{table} 문자열의 순서\n",
    ":name: char_order\n",
    "|단어|Q|u|a|n|t|\n",
    "|---|---|---|---|---|---|\n",
    "|위치|0|1|2|3|4|5|\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "933ffd91",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'n'"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "var[-2]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2359e642",
   "metadata": {},
   "source": [
    "인덱싱에 마이너스(-) 기호를 붙이면 문자열을 뒤에서부터 읽는다. 즉 `var[-2]`은 뒤에서 두번째 문자를 의미하며 이에 해당하는 'n'이 출력되었다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "50f7e74a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Qua'"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "var[0:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "df50012a",
   "metadata": {},
   "source": [
    "슬라이싱은 [] 내부에 콜론(:) 기호를 사용하여 `시작:마지막`에 해당하는 문자를 출력한다. 즉 `var[0]` 부터 `var[3]`까지를 출력한다. 그런데 Quant에서 3에 해당하는 단어는 n임에도 불구하고 그 이전인 Qua 까지만 출력이 되었다. 이는 슬라이싱에서 `var[시작:마지막]`을 지정할 때 마지막 번호에 해당하는 단어는 포함되지 않기 때문이며, `var[0:3]`은 0 이상 3 미만에 해당하는 문자만 출력한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "c58a028d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Qu'"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "var[:2]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3f18f93e",
   "metadata": {},
   "source": [
    "시작에 해당하는 부분을 명시하지 않으면 처음(0)부터 2 미만까지의 문자를 출력한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "f5906b72",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'nt'"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "var[3: ]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d2a59f4a",
   "metadata": {},
   "source": [
    "반대로 마지막에 해당하는 부분을 명시하지 않으면 3부터 마지막까지 문자를 출력한다.\n",
    "\n",
    "### 리스트\n",
    "\n",
    "파이썬에서는 연속된 데이터를 표현하기 위해 리스트(List) 자료형을 사용한다. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "507a669e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "list"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = []\n",
    "type(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "78f55da3",
   "metadata": {},
   "source": [
    "리스트는 대괄호([ ])를 이용하여 생성할 수 있으며, 아무 값도 입력하지 않을 경우 빈 리스트가 생성된다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "ebecd133",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "list_num = [1, 2, 3]\n",
    "print(list_num)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "b634db25",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['a', 'b', 'c']\n"
     ]
    }
   ],
   "source": [
    "list_char = ['a', 'b', 'c']\n",
    "print(list_char)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "c528cb6e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 'a', 2]\n"
     ]
    }
   ],
   "source": [
    "list_complex = [1, 'a', 2]\n",
    "print(list_complex)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "46ad7401",
   "metadata": {},
   "source": [
    "리스트 내부에 각 요소는 쉼표(,)를 이용해 구분해준다. 요소값은 숫자(list_num), 문자열(list_char), 혹은 숫자와 문자열(list_complex)을 함께 가질 수도 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "7a3ab21c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, ['a', 'b']]\n"
     ]
    }
   ],
   "source": [
    "list_nest = [1, 2, ['a', 'b']]\n",
    "print(list_nest)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2894ca68",
   "metadata": {},
   "source": [
    "혹은 리스트 자체를 하나의 요솟값으로 가질 수도 있다. 즉 리스트 안에는 어떠한 자료형도 들어갈 수 있다.\n",
    "\n",
    "#### 리스트 인덱싱과 슬라이싱\n",
    "\n",
    "리스트도 문자열과 동일한 방법으로 인덱싱과 슬라이싱을 할 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "e24013f7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "var = [1, 2, ['a', 'b', 'c']]\n",
    "\n",
    "var[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "442b9864",
   "metadata": {},
   "source": [
    "문자열과 동일하게 `var[0]`을 입력할 경우 해당 요소값인 1이 출력된다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "0f8bc657",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['a', 'b', 'c']"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "var[2]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0c66021d",
   "metadata": {},
   "source": [
    "`var[2]`를 입력할 경우 ['a', 'b', 'c']라는 리스트가 출력된다. 추가로 ['a', 'b', 'c'] 리스트에서 'a'라는 문자열만 추출하는 방법은 다음과 같다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "62c25bca",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'a'"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "var[2][0]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "194bc2f9",
   "metadata": {},
   "source": [
    "먼저 `var[2]`를 통해 ['a', 'b', 'c']를 추출하며, 뒤에 `[0]`을 추가적으로 붙여 첫번째 요소인 'a'가 출력된다. 이처럼 중첩된 리스트에서도 인덱싱은 여러번 하면 얼마든지 원하는 값을 선택할 수 있다. 이번에는 리스트의 슬라이싱에 대해서 살펴보자."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "ba66bd4a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2]"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "var = [1, 2, 3, 4, 5]\n",
    "var[0:2]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ceb7b43d",
   "metadata": {},
   "source": [
    "문자열의 슬라이싱과 동일하게 `var[0:2]`를 입력하면 리스트 a의 0 이상 2 미만에 해당하는 요소들이 출력된다.\n",
    "\n",
    "#### 리스트 연산하기\n",
    "\n",
    "리스트도 `+`, `*` 연산을 제한적으로 사용할 수 있다. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "7968a427",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6]"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = [1, 2, 3]\n",
    "b = [4, 5, 6]\n",
    "\n",
    "a+b"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d88d83c9",
   "metadata": {},
   "source": [
    "리스트 사이에 `+` 기호를 사용하면 두 리스트를 하나로 합친다. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "89eba221",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 1, 2, 3, 1, 2, 3]"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = [1, 2, 3]\n",
    "a * 3"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "de605d72",
   "metadata": {},
   "source": [
    "리스트에 `*` 기호를 사용하면 해당 리스트를 n번 반복한다.\n",
    "\n",
    "#### 리스트에 요소 추가하기\n",
    "\n",
    "다양한 방법을 통해 기존의 리스트에 새로운 데이터를 추가하거나 삽입할 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "1d06efaf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "var = [1, 2, 3]\n",
    "var.append(4)\n",
    "print(var)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "37cf0bae",
   "metadata": {},
   "source": [
    "`append()` 메서드는 기존의 리스트 맨 마지막에 데이터를 추가한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "7aedbd82",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, [4, 5]]\n"
     ]
    }
   ],
   "source": [
    "var = [1, 2, 3]\n",
    "var.append([4, 5])\n",
    "print(var)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a5379778",
   "metadata": {},
   "source": [
    "만약 `append()` 메서드 내에 리스트 형태를 입력할 경우 중첩된 형태로 데이터가 추가된다. 리스트에 새로운 리스트를 중첩된 형태가 아니라 리스트 형태로 확장하고 싶을 경우에는 `extend()` 메서드를 사용하면 된다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "58e029f6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "var = [1, 2, 3]\n",
    "var.extend([4, 5])\n",
    "print(var)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "23ad2b47",
   "metadata": {},
   "source": [
    "`extend()` 메서드 내의 리스트인 [4, 5]가 중첩된 형태가 아니라 기존 데이터인 [1, 2, 3] 뒤에 확장이 되었다.\n",
    "\n",
    "#### 리스트의 수정과 삭제\n",
    "\n",
    "인덱싱과 슬라이싱을 이용하면 리스트의 요소를 수정 혹은 삭제할 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "9cc333d3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 10, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "var = [1,2,3,4,5]\n",
    "var[2] = 10\n",
    "print(var)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3b03ba33",
   "metadata": {},
   "source": [
    "먼저 var라는 변수에 1부터 5까지 숫자로 구성된 리스트를 만들었다. 그 후 var의 두번재 요소에 10을 입력하면 해당 값으로 요소가 변경되었다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "4c7f423f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 10, ['a', 'b', 'c'], 5]\n"
     ]
    }
   ],
   "source": [
    "var[3] = ['a', 'b', 'c']\n",
    "print(var)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9acd70ea",
   "metadata": {},
   "source": [
    "이번에는 세번째 요소를 ['a', 'b', 'c']라는 요소로 변경하였다. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "0e3f97e6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['가', '나', 10, ['a', 'b', 'c'], 5]\n"
     ]
    }
   ],
   "source": [
    "var[0 : 2] = ['가', '나']\n",
    "print(var)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7f7e10eb",
   "metadata": {},
   "source": [
    "슬라이싱을 이용해 데이터를 수정할 수도 있다. `var[0 : 2]`는 0 부터 1 까지의 데이터를 의미하며, 해당 데이터를 ['가', '나']로 변경하였다.\n",
    "\n",
    "이번에는 리스트에서 요소를 삭제하는 방법에 대해 살펴보겠으며, 먼지 `del` 명령어를 사용하는 방법에 대해 알아보자."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "cc50e413",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 3]\n"
     ]
    }
   ],
   "source": [
    "var = [1, 2, 3]\n",
    "del var[0]\n",
    "print(var)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1f564b00",
   "metadata": {},
   "source": [
    "`del 객체`를 이용하여 데이터를 삭제할 수 있다. 위의 예제에서 `del var[0]`는 var에서 첫번째 요소를 삭제하라는 의미다. 인덱싱 뿐만 아니라 `dal var[0:2]`와 같이 슬라이싱을 통해서도 데이터를 삭제할 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "3a4bee93",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 3]\n"
     ]
    }
   ],
   "source": [
    "var = [1, 2, 3]\n",
    "var[0:1] = []\n",
    "print(var)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5f68bd40",
   "metadata": {},
   "source": [
    "슬라이싱을 통해 범위를 지정한 후 빈 리스트([])를 입력하여 해당 부분의 데이터를 삭제할 수도 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "c7a6bbb1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 3, 1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "var = [1, 2, 3, 1, 2, 3]\n",
    "var.remove(1)\n",
    "print(var)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "06610443",
   "metadata": {},
   "source": [
    "`remove(x)` 메서드는 리스트에서 첫 번째로 나오는 x를 삭제하는 함수이다. 위 예제에서는 가장 먼저 나오는 1이 삭제된 것을 확인할 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "44d363b6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "var = [1, 2, 3]\n",
    "var.pop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "362326e9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2]\n"
     ]
    }
   ],
   "source": [
    "print(var)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e62d36fd",
   "metadata": {},
   "source": [
    "`pop()` 메서드는 리스트의 맨 마지막 요소를 반환하고 해당 요소는 삭제한다. 위 예에서 가장 마지막 요소인 3이 출력되고, var를 확인해보면 최종적으로 [1, 2]만 남아있다.\n",
    "\n",
    "#### 리스트 정렬하기\n",
    "\n",
    "리스트 내의 데이터들은 `sort()` 메서드를 통해 정렬할 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "b82552bc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "var = [2, 4, 1, 3]\n",
    "var.sort()\n",
    "print(var)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d36932ca",
   "metadata": {},
   "source": [
    "1부터 4까지의 순서가 무작위로 존재했지만, `sort()`를 입력하면 오름차순으로 정렬된다.\n",
    "\n",
    "### 튜플\n",
    "\n",
    "튜플(Tuple) 자료형은 리스트와 매우 흡사하며 약간의 차이점만 있다. 먼저 리스트는 대괄호([ ])를 이용해 생성하지만 튜플은 소괄호(( ))를 이용해 생성한다. 또한 튜플은 값을 수정하거나 삭제할 수 없다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "6a7a541e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tuple"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "var = ()\n",
    "type(var)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ee9516ee",
   "metadata": {},
   "source": [
    "리스트와 마찬가지로 소괄호를 입력하면 빈 튜플이 생성된다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "6f5267b7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1,)\n"
     ]
    }
   ],
   "source": [
    "var = (1, )\n",
    "print(var)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3a9702b4",
   "metadata": {},
   "source": [
    "만일 값이 하나만 있을 경우에는 요소 뒤에 콤마(,)를 반드시 붙여야 한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "8357f7bc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, ('a', 'b'))\n"
     ]
    }
   ],
   "source": [
    "var = (1, 2, ('a', 'b'))\n",
    "print(var)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2fb84e63",
   "metadata": {},
   "source": [
    "튜플 역시 요소를 중첩하여 사용할 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c9184e33",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "var = (1, 2)\n",
    "del var[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9cd1b41e",
   "metadata": {},
   "source": [
    "```{figure} image/python/tuple_error.png\n",
    "---\n",
    "name: tuple_error\n",
    "---\n",
    "```\n",
    "\n",
    "만일 `del` 명령어를 이용해 요소값을 삭제하려고 할 경우 오류가 발생한다. 이처럼 튜플은 수정 혹은 삭제가 불가능하다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "b544511c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "var = (1, 2, 3, 4, 5)\n",
    "var[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "64fb3387",
   "metadata": {},
   "source": [
    "인덱싱이나 슬라이싱의 경우 리스트와 동일하게 사용이 가능하다.\n",
    "\n",
    "### 딕셔너리\n",
    "\n",
    "딕셔너리(Dictionary)는 대응 관계를 나타내는 자료형으로써, 리스트나 튜플처럼 순서가 존재하지 않으며 대신 Key와 Value가 존재한다. 딕셔너리는 다음과 같은 형태를 가지고 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5fde47b5",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "{Key1:Value1, Key2:Value2, Key3:Value3, ...}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "29cc8b08",
   "metadata": {},
   "source": [
    "딕셔너리는 중괄호({ })를 감싸서 표현한다. 키(Key)-값(Value)의 형태로 데이터가 이루어져 있으며, 각각은 쉼표(,)로 구분된다. 예시를 살펴보도록 하자."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "f6e114c7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'key1': 1, 'key2': 2}\n"
     ]
    }
   ],
   "source": [
    "var = {'key1' : 1, 'key2' : 2}\n",
    "print(var)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "58e1ab5b",
   "metadata": {},
   "source": [
    "키 값이 key1인 곳에는 1이라는 값이, 키 값이 key2인 곳에는 2라는 값이 딕셔너리 형태로 입력되었다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "88103011",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'key1': [1, 2, 3], 'key2': ('a', 'b', 'c')}\n"
     ]
    }
   ],
   "source": [
    "var = {'key1': [1, 2, 3], 'key2': ('a', 'b', 'c')}\n",
    "print(var)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "43398c6b",
   "metadata": {},
   "source": [
    "딕셔너리의 값에는 리스트나 튜플 형태도 입력이 가능하다.\n",
    "\n",
    "#### Key를 사용해 Value 구하기\n",
    "\n",
    "문자열이나 리스트, 튜플의 경우 인덱싱이나 슬라이싱을 통해 요소값을 구할 수 있었지만, 딕셔너리는 순서가 존재하지 않으므로 이러한 방법을 사용할 수 없다. 딕셔너리는 Key를 사용해 이에 해당되는 Value를 얻을 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "5a7b9e1c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "var = {'key1': 1, 'key2': 2, 'key3': 3}\n",
    "var['key1']"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "20ca6b79",
   "metadata": {},
   "source": [
    "먼저 var라는 변수에 딕셔너리를 입력한 후, `var['key1']`을 입력하면 딕셔너리 중 Key값이 key1에 해당하는 데이터의 Value를 반환한다. 즉 딕셔너리 변수에서 [ ] 안의 값은 순서를 뜻하는 것이 아니라 Key 값을 의미한다.\n",
    "\n",
    "#### 쌍 추가하기 및 삭제하기\n",
    "\n",
    "기존 딕셔너리에 쌍을 추가하는 방법과 삭제하는 방법에 대해 살펴보자."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "a2ccc85e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'key1': 1, 'key2': 2, 'key3': 3}\n"
     ]
    }
   ],
   "source": [
    "var = {'key1': 1, 'key2': 2}\n",
    "var['key3'] = 3\n",
    "print(var)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2fa4800d",
   "metadata": {},
   "source": [
    "먼저 key1과 key2로 이루어진 딕셔너리를 만들었다. 그 후 `var['key3'] = 3`을 입력하면 Key는 key3, Value는 3인 딕셔너리 쌍이 추가된다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "546dcd1a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'key2': 2, 'key3': 3}\n"
     ]
    }
   ],
   "source": [
    "del var['key1']\n",
    "print(var)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0c6d7fc7",
   "metadata": {},
   "source": [
    "리스트와 마찬가지로 딕셔너리에서도 `del` 명령어를 사용하면 해당 Key를 가진 딕셔너리 쌍이 삭제된다.\n",
    "\n",
    "#### Key와 Value 구하기\n",
    "\n",
    "이번에는 딕셔너리의 Key와 Value를 한번에 구하는 법에 대해 살펴보자."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "25b53c49",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys(['key1', 'key2', 'key3'])"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "var = {'key1': 1, 'key2': 2, 'key3': 3}\n",
    "var.keys()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "28f66da2",
   "metadata": {},
   "source": [
    "`var.keys()`를 입력하면 var라는 딕셔너리에서 Key만을 모아 dict_keys 객체로 반환한다. 만일 이를 리스트 형태로 만들고자할 때는 다음과 같이 하면 된다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "b3664740",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['key1', 'key2', 'key3']"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(var.keys())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "814f8604",
   "metadata": {},
   "source": [
    "결과를 `list()`로 감싸주면 Key값이 리스트 형태로 출력된다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "89ae57b3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_values([1, 2, 3])"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "var.values()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e0a75bab",
   "metadata": {},
   "source": [
    "`var.values()`는 var라는 딕셔너리에서 값만을 모아 dict_values 객체로 반환한다.\n",
    "\n",
    "### 집합\n",
    "\n",
    "집합(Set)은 집합에 관련된 자료형이며, `set()` 키워드를 사용해 만들 수 있다. 집합 자료형의 특징으로는 중복을 허용하지 않는다는 점과, 순서가 없다는 점이다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "9687d3de",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3}\n"
     ]
    }
   ],
   "source": [
    "set1 = set([1, 2, 3])\n",
    "print(set1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "deb00dd6",
   "metadata": {},
   "source": [
    "`set()` 내에 리스트를 입력하면 집합이 만들어진다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "f0247dd1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'n', 'a', 'b'}\n"
     ]
    }
   ],
   "source": [
    "set2 = set('banana')\n",
    "print(set2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d7146ed1",
   "metadata": {},
   "source": [
    "반면 `set()` 내에 banana라는 단어를 입력했더니 'a', 'b', 'n'만 입력이 되었다. 이는 집합이 중복을 허용하지 않기 때문에 고유한 값만이 남았으며, 순서도 입력한 것과 다르다.\n",
    "\n",
    "#### 합집합, 교집합, 차집합 구하기\n",
    "\n",
    "집합 자료형을 통해 합집합, 교집합, 차집합을 구해보도록 하자.\n",
    "\n",
    "```{figure} image/python/set.png\n",
    "---\n",
    "name: set\n",
    "---\n",
    "집합 연산의 종류\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "845c90e9",
   "metadata": {},
   "outputs": [],
   "source": [
    "s1 = set([1, 2, 3, 4])\n",
    "s2 = set([3, 4, 5, 6])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a7b4dd9b",
   "metadata": {},
   "source": [
    "먼저 합집합을 구해보도록 하자. 합집합이란 하나에라도 속하는 원소들을 모두 모은 집합이다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "45fc54fa",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 4, 5, 6}"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s1.union(s2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "67148b02",
   "metadata": {},
   "source": [
    "`union()` 메서드를 사용하면 합집합을 구할 수 있다. 즉 1부터 6까지의 숫자가 집합에 입력되며, 두 집합에 공통으로 존재하는 3과 4는 한번만 입력이 된다.\n",
    "\n",
    "다음으로 교집합을 구해보도록 하자. 교집합이란 두 집합이 공통으로 포함하는 원소로 이루어진 집합이다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "4c364cab",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{3, 4}"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s1.intersection(s2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7eeb3abc",
   "metadata": {},
   "source": [
    "`intersection()` 메서드를 사용하면 교집합을 구할 수 있다. 즉 두 집합에 공통으로 존재하는 3과 4가 반환된다. \n",
    "\n",
    "마지막으로 차집합을 구해보도록 하자. 차집합이란 집합 A에는 속하지만 집합 B에는 속하지 않는 원소들로 이루어진 집합이다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "1ea83bf1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2}"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s1.difference(s2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4610a5f4",
   "metadata": {},
   "source": [
    "`difference()` 메서드를 사용하면 집합 s1에서 교집합을 제외한 {1, 2}만이 반환된다.\n",
    "\n",
    "### 불리언\n",
    "\n",
    "불리언(Boolean) 자료형이란 참(True) 혹은 거짓(False)을 나타내는 자료형으로, 이 두가지 값만을 가질 수 있다. 참고로 True와 False는 첫 문자는 항상 대문자로 사용해야 한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "ff1c73ff",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "bool"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "var = True\n",
    "type(var)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "92fdb2de",
   "metadata": {},
   "source": [
    "var 변수에 True를 입력한 후 타입을 확인해보면 bool, 즉 불리언 자료형임을 알 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "c27b63e1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 == 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fbdcf1fb",
   "metadata": {},
   "source": [
    "파이썬에서 `==` 는 양측 값이 같은지를 확인하는 비교연산자이다. 좌측의 1과 우측의 1은 같으므로 True 즉 참이 반환된다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "89fe8622",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 != 2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b73afc00",
   "metadata": {},
   "source": [
    "`!=` 는 양측 값이 다른지를 확인하는 비교연산자이다. 좌측의 1과 우측의 2는 다르므로 역시나 True가 반환된다.\n",
    "\n",
    "#### 자료형의 참과 거짓\n",
    "\n",
    "자료형 자체에도 참과 거짓이 존재한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "ab69a725",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bool(0)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "553343b0",
   "metadata": {},
   "source": [
    "`bool()` 함수는 참(True)과 거짓(False)을 반환하는 함수다. 숫자 0은 False에 해당한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "5249b780",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bool(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "8a85c25d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bool(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fdf1b580",
   "metadata": {},
   "source": [
    "반면 0이 아닌 숫자는 True에 해당한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "e110db07",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bool(None)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4dfaacff",
   "metadata": {},
   "source": [
    "None은 값의 부재를 나타내는데 사용되며, False에 해당한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "id": "148d9439",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bool(\"\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "id": "14a3caaf",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bool([])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "id": "452f6e64",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bool({})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "id": "3d3c714f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bool(())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fa632371",
   "metadata": {},
   "source": [
    "문자열, 리스트, 딕셔너리, 튜플 등의 값이 비어 있을 경우는 False에 해당한다. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "id": "fd6b185f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bool('Python')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "id": "2af1dacc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bool([1, 2, 3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "id": "d00884bb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bool({'Key':'Value'})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "id": "0e1919b8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bool((1, 2))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9e2cc90a",
   "metadata": {},
   "source": [
    "반면 데이터가 존재하면 True에 해당한다. 이를 요약하면 다음과 같다.\n",
    "\n",
    "```{table} 자료형의 참과 거짓\n",
    ":name: data_bool\n",
    "|값|True or False|\n",
    "|---|---|\n",
    "| 0 | False |\n",
    "| 0 외의 숫자 | True |\n",
    "| None | False |\n",
    "| \"\" | False |\n",
    "| [] | False |\n",
    "| {} | False |\n",
    "| () | False |\n",
    "| [데이터] | True |\n",
    "| {key:value} | True |\n",
    "| (데이터) | True |\n",
    "```\n",
    "\n",
    "### 날짜와 시간\n",
    "\n",
    "날짜와 시간은 파이썬에서 기본으로 제공하는 자료형에는 포함되어 있지 않지만 데이터 분석을 할 때 빈번하게 다루는 자료형이다. 날짜와 시간과 관련된 패키지는 다음과 같다.\n",
    "\n",
    "#### 날짜와 시간 구하기\n",
    "\n",
    "`datetime` 패키지를 이용해 현재 날짜 및 시간 정보를 구할 수 있다(패키지에 대한 자세한 설명은 이번 장의 맨 마지막에서 자세히 다룬다)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "id": "d8134767",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "datetime.datetime(2024, 2, 12, 16, 49, 20, 306183)"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import datetime\n",
    "\n",
    "var = datetime.datetime.now()\n",
    "var"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "id": "7540f6da",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "datetime.datetime"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(var)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a1697429",
   "metadata": {},
   "source": [
    "`datetime` 클래스의 `now()` 메서드는 현재 날짜와 시간을 반환한다. 앞에서부터 [연도, 월, 일, 시, 분, 초, 마이크로초]를 의미한다. 이 중 연도에 해당하는 부분만 선택해보자."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "id": "f4f64129",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2024\n"
     ]
    }
   ],
   "source": [
    "print(var.year)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c62e03e7",
   "metadata": {},
   "source": [
    "`var.` 뒤에 속성을 입력하면 이에 해당하는 값이 출력된다. 날짜와 시간과 관련된 속성은 다음과 같다.\n",
    "\n",
    "- year: 연도\n",
    "- month: 월\n",
    "- day: 일\n",
    "- hour: 시\n",
    "- minute: 분\n",
    "- second: 초\n",
    "- microsecond: 마이크로초 (백만분의 일초)\n",
    "\n",
    "각 속성을 한번에 출력해보도록 하자."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "id": "de13b253",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2024, 2, 12, 16, 49, 20, 306183)"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "var.year, var.month, var.day, var.hour, var.minute, var.second, var.microsecond"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b485da4f",
   "metadata": {},
   "source": [
    "datetime 클래스에는 이 외에도 다양한 메서드가 존재한다. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "id": "92f0d719",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "var.weekday()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a9f775fd",
   "metadata": {},
   "source": [
    "`weekday`는 요일을 반환한다. 결과값으로 0은 월요일, 1은 화요일, 2는 수요일, 3은 목요일, 4은 금요일, 5는 토요일, 6은 일요일을 뜻한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "id": "f7186d36",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(datetime.date(2024, 2, 12), datetime.time(16, 49, 20, 306183))"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "var.date(), var.time()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3773f557",
   "metadata": {},
   "source": [
    "`date()`는 날짜에 관련된 정보만, `time()`은 시간에 관련된 정보만 반환한다. \n",
    "\n",
    "#### 포맷 바꾸기\n",
    "\n",
    "포맷을 바꾸는데는 크게 두가지 메서드가 사용된다.\n",
    "\n",
    "- `strftime`: 시간 정보를 문자열로 바꿈\n",
    "- `strptime`: 문자열을 시간 정보로 바꿈\n",
    "\n",
    "먼저 `strftime`를 이용해 시간 정보를 문자 정보로 바꿔보도록 하자."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "id": "ff3010b8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "datetime.datetime(2024, 2, 12, 16, 49, 20, 306183)"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "var"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0ab490c9",
   "metadata": {},
   "source": [
    "위의 시간 정보를 일반적으로 많이 사용하는 'yyyy-mm-dd', 즉 '연도-월-일' 형태로 바꿔보도록 하자."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "id": "65f12327",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'2024-02-12'"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "var.strftime('%Y-%m-%d')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "123f93bf",
   "metadata": {},
   "source": [
    "\\%Y, \\%m, \\%d는 날짜 및 시간을 어떤 형식의 문자열로 만들지 결정하는 형식 문자열이다. 날짜 및 시간을 나타내는 형식은 다음과 같다.\n",
    "\n",
    "```{table} 날짜 및 시간 관련 포맷 코드\n",
    ":name: data_bool\n",
    "| 그룹 | 코드 | 뜻 |\n",
    "| --- | --- | --- |\n",
    "| 년 | %Y | 연도 (전체)  |\n",
    "|    | %y | 연도 (뒤 2자리만) |\n",
    "| 월 | %m | 월 |\n",
    "|    | %B | Locale 월 표현 (전체) |\n",
    "|    | %b | Locale 월 표현 (축약) |\n",
    "| 일 | %d | 일 |\n",
    "|    | %j | 연중 일 |\n",
    "| 시 | %H | 시 (24시간) |\n",
    "|    | %I | 시 (12시간) |\n",
    "|    | %p | Locale 오전, 오후 |\n",
    "| 분 | %M | 분 |\n",
    "| 초 | %S | 초 |\n",
    "| 마이크로초 | %f | 마이크로초 |\n",
    "| 요일 | %w | 요일 |\n",
    "| | %A | Locale 요일 (전체) |\n",
    "| | %a | Locale 요일 (축약형) |\n",
    "| 주 | %W | 연중 몇 번째 주인지 표현 (월요일 시작 기준) |\n",
    "| | %U | 연중 몇 번째 주인지 표현 (일요일 시작 기준) |\n",
    "| 날짜 표현 | %c | Locale 날짜와 시간 표현 |\n",
    "| | %x | Locale 날짜 표현 |\n",
    "| | %X | Locale 시간 표현 |\n",
    "```\n",
    "\n",
    "예를 들어 시간 정보를 문자열로 바꿔보도록 하자."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "id": "218362cb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Sat 31, Dec 22'"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t = datetime.datetime(2022, 12, 31, 11, 59, 59)\n",
    "\n",
    "t.strftime(\"%a %d, %b %y\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "id": "47738d3e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'11시 59분 59초'"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t.strftime(\"%H시 %M분 %S초\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1f352d50",
   "metadata": {},
   "source": [
    "반대로 문자열로부터 날짜와 시간 정보를 읽은 후 `datetime` 클래스 객체로 만들 수 있으며, 이 경우 `strptime` 메서드를 사용한다. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "id": "40b589df",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "datetime.datetime(2022, 12, 31, 11, 59, 59)"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "datetime.datetime.strptime(\"2022-12-31 11:59:59\", \"%Y-%m-%d %H:%M:%S\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c7b3fb86",
   "metadata": {},
   "source": [
    "첫 번째 인자에 날짜와 시간 정보를 가진 문자열을, 두 번째 인자에 이에 해당하는 형식 문자열을 입력하면 `datetime` 클래스 객체로 변경된다.\n",
    "\n",
    "#### 날짜와 시간 연산하기\n",
    "\n",
    "날짜 혹은 시간의 간격을 구할 수도 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "id": "beaa313b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "datetime.timedelta(days=365)"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dt1 = datetime.datetime(2022, 12, 31)\n",
    "dt2 = datetime.datetime(2021, 12, 31)\n",
    "td = dt1 - dt2\n",
    "\n",
    "td"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cf55e426",
   "metadata": {},
   "source": [
    "2022년 12월 31일에서 2021년 12월 31일을 빼면 days=365, 즉 365일의 차이가 있음을 확인할 수 있다. 이번에는 날짜에 특정 기간을 더해보도록 하자."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "id": "4fd42210",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "datetime.datetime(2022, 1, 1, 0, 0)"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dt1 = datetime.datetime(2021, 12, 31)\n",
    "dt1 + datetime.timedelta(days = 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "728f8970",
   "metadata": {},
   "source": [
    "`timedelta` 객체를 통해 원하는 기간을 더해거나 빼줄 수 있다. 2021년 12월 31일에 `days = 1`, 즉 1일을 더하면 다음날인 2022년 1월 1일이 계산된다. 그러나 `timedelta` 객체의 단점은 날짜와 초 단위로만 연산을 할 수 있다는 점이며, 월 단위의 경우 `dateutil` 패키지의 `relativedelta` 클래스를 이용하면 된다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "id": "8c0e0e6a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "datetime.datetime(2022, 1, 31, 0, 0)"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from dateutil.relativedelta import relativedelta\n",
    "\n",
    "dt1 + relativedelta(months = 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e18d2295",
   "metadata": {},
   "source": [
    "`timedelta`와 사용법은 같으며, `months = 1`을 통해 한 달의 기간을 더할 수 있다.\n",
    "\n",
    "#### 코드를 일시정지 하기\n",
    "\n",
    "time 패키지의 `sleep()` 함수를 사용하면 일정 시간동안 프로세스를 일시정지할 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "id": "da1403be",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "2024-02-12 16:49:20.401262\n",
      "-------\n",
      "1\n",
      "2024-02-12 16:49:22.401705\n",
      "-------\n",
      "2\n",
      "2024-02-12 16:49:24.402400\n",
      "-------\n"
     ]
    }
   ],
   "source": [
    "import datetime\n",
    "import time\n",
    "\n",
    "for i in range(3) :\n",
    "    print(i)    \n",
    "    print(datetime.datetime.now())\n",
    "    print('-------')\n",
    "    time.sleep(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ffae752d",
   "metadata": {},
   "source": [
    "위 코드는 0부터 2까지 for문 내에서 i와 현재 시간을 출력하며, `time.sleep(2)`을 통해 루프당 2초의 일시정지를 준다. 출력된 결과를 살펴보면 한 번의 루프가 끝난 후 약 2초 후에 다음 루프가 실행된 것을 확인할 수 있다.\n",
    "\n",
    "## 제어문\n",
    "\n",
    "파이썬 프로그래밍은 위에서부터 아래 방향으로 작성된 내용을 순서대로 실행한다. 반면 이러한 흐름을 제어하여 실행 순서를 바꾸거나 여러 번 반복하도록 하는 것이 제어문이다. 파이썬의 제어문에는 크게 if문, while문, for문이 있다.\n",
    "\n",
    "### if 문\n",
    "\n",
    "if문, 혹은 조건문이란 입력된 조건을 판단하여 해당 조건에 맞는 상황을 실행한다. if문의 기본적인 구조는 다음과 같다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "63b55baa",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "if 조건:\n",
    "    실행"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a410f153",
   "metadata": {},
   "source": [
    "1. `if`를 통해 if문을 선언하고, 바로 뒤에 조건을 입력한 후 콜론(:)을 붙인다.\n",
    "2. 줄바꿈을 해준 후 만일 조건이 True일 경우 실행할 코드를 입력한다. 이 때 조건문 바로 아래부터는 if문에 속하는 문장이므로 들여쓰기를 해주어야 하며, 공백을 4번 입력하거나 탭을 누른다. 만일 들여쓰기가 제대로 되지 않을 경우 오류가 발생한다. \n",
    "\n",
    "예를 살펴보도록 하자."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "id": "9d05b4df",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "값이 0보다 큽니다.\n"
     ]
    }
   ],
   "source": [
    "x = 2\n",
    "\n",
    "if x > 0:\n",
    "    print('값이 0보다 큽니다.')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a50ca893",
   "metadata": {},
   "source": [
    "1. 먼저 x라는 변수에 2라는 숫자를 입력한다.\n",
    "2. `if`를 통해 조건을 선언하며 조건에는 `x > 0`을 설정한 후 콜론을 입력한다.\n",
    "3. 만일 위 조건이 True일 경우 '값이 0보다 큽니다.'를 출력한다.\n",
    "\n",
    "실제 결과를 살펴보다 2는 0보다 크므로 해당 문장이 출력된다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "id": "fb32c010",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = -1\n",
    "\n",
    "if x > 0:\n",
    "    print('값이 0보다 큽니다.')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7e3d3227",
   "metadata": {},
   "source": [
    "반면 위의 경우 코드를 실행해도 아무런 결과가 나타나지 않는다. 이는 x에 입력된 -1이 0보다 작으므로 조건이 False이기 때문이다. 이처럼 조건문이 False일때 실행할 상황은 `else`를 이용한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "716f4624",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "if 조건:\n",
    "    실행 1\n",
    "else:\n",
    "    실행 2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "78061541",
   "metadata": {},
   "source": [
    "만일 조건이 True일 경우에는 [실행 1]에 해당하는 코드가 실행되지만, 그렇지 않을 경우 [실행 2]에 해당하는 코드가 실행된다. `if`와 마찬가지로 `else`문 아래의 문장도 들여쓰기를 해주어야 한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "id": "58af1931",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "값이 음수입니다.\n"
     ]
    }
   ],
   "source": [
    "x = -1\n",
    "\n",
    "if x > 0:\n",
    "    print('값이 0보다 큽니다.')\n",
    "else:\n",
    "    print('값이 음수입니다.')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4823fcf4",
   "metadata": {},
   "source": [
    "-1이 0보다 작으므로 조건은 False다. 따라서 else에 속하는 '값이 음수입니다.'가 출력된다. 만일 조건이 여러개인 다중 조건을 판단하려면 `if`와 `else` 사이에 `elif`를 추가하면 된다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fe563d32",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "if 조건 1:\n",
    "    실행 1\n",
    "elif 조건 2:\n",
    "    실행 2\n",
    "elif 조건 3:\n",
    "    실행 3\n",
    "...\n",
    "else:\n",
    "    실행 n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a70d143c",
   "metadata": {},
   "source": [
    "`if`의 [조건 1]이 False일 경우 바로 아래의 `elif`를 통해 [조건 2]를 판단한다. 만일 [조건 2]가 True일 경우에는 [실행 2]에 해당하는 코드가 실행되지만, False일 경우에는 다시 [조건 3]을 판단한다. 만일 모든 `elif`의 조건이 False일 경우 최종적으로 [실행 n]에 해당하는 코드가 실행되며, `elif`는 개수에 제한 없이 사용할 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "id": "ae0ff727",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "값이 0 이상 10 미만입니다.\n"
     ]
    }
   ],
   "source": [
    "x = 3\n",
    "\n",
    "if x >= 10:\n",
    "    print('값이 10보다 큽니다.')\n",
    "elif x >= 0:\n",
    "    print('값이 0 이상 10 미만입니다.')\n",
    "else:\n",
    "    print('값이 음수입니다.')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d3d5ef7a",
   "metadata": {},
   "source": [
    "먼저 `if` 조건에서 3은 10 보다 크지 않으므로 조건이 False이며, 이에 해당하는 코드가 실행되지 않는다. 그 후 `elif` 조건에서 3은 0보다 크므로 이에 해당하는 코드인 '값이 0 이상 10 미만입니다.'가 출력된다.\n",
    "\n",
    "만일 조건문이 `if`와 `else`로만 구성될 경우 다음과 같이 간단하게 작성할 수도 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b6d8ddc2",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "[조건문이 True인 경우] if 조건문 else [조건문이 False 경우]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ff88c329",
   "metadata": {},
   "source": [
    "예제를 살펴보도록 하자."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "id": "1afa5b92",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'0 이상'"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 7\n",
    "\n",
    "'0 이상' if x >= 0 else '음수'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6a2fcfff",
   "metadata": {},
   "source": [
    "x가 0 이상일 경우에는 '0 이상'을 출력하며, 그렇지 않을 경우엔 '음수'를 출력한다. 이처럼 조건부 표현식은 한 줄로 작성할 수 있어 훨씬 가독성이 좋다.\n",
    "\n",
    "### while문\n",
    "\n",
    "while문, 혹은 반복문은 특정 조건을 만족하는 동안 반복해서 코드를 실행한다. while문의 기본적인 구조는 다음과 같다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "90bccbbc",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "while 조건:\n",
    "    실행"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2e81588d",
   "metadata": {},
   "source": [
    "[조건]에 해당하는 부분이 True인 동안에는 [실행]에 해당하는 코드가 반복해서 수행된다. while문도 if문과 마찬가지로 [실행]에 해당하는 부분은 들여쓰기를 해주어야 한다. 예제를 살펴보도록 하자."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "id": "510b6ea9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "num = 1\n",
    "\n",
    "while num < 5:\n",
    "    print(num)\n",
    "    num = num + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e2b990cc",
   "metadata": {},
   "source": [
    "1. 먼저 num에 1을 입력한다.\n",
    "2. 만일 num이 5 미만일 경우 아래의 코드를 계속해서 수행한다.\n",
    "3. num을 출력한다.\n",
    "4. num에 1을 더한다.\n",
    "\n",
    "1부터 4까지 숫자가 출력되다가, num이 5가 된 순간에는 while문의 조건이 False 이므로 코드 실행이 종료된다. 만약 `num = num + 1` 부분이 없다면 num은 계속 1인 상태이므로 `print(num)`이 무한대로 실행된다.\n",
    "\n",
    "`while`문 내부에 `if`문을 추가할 수도 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "id": "587c3a5e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2은 짝수입니다.\n",
      "4은 짝수입니다.\n",
      "6은 짝수입니다.\n",
      "8은 짝수입니다.\n"
     ]
    }
   ],
   "source": [
    "num = 1\n",
    "\n",
    "while num < 10 :\n",
    "    if num % 2 == 0 :\n",
    "        print(f'{num}은 짝수입니다.')    \n",
    "    num = num + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "53b8b18a",
   "metadata": {},
   "source": [
    "1. num에 1을 입력한다.\n",
    "2. `while`을 통해 num이 10 미만일 경우 아래의 코드를 계속해서 수행한다.\n",
    "3. `if`를 추가하여 num % 2 == 0일 경우, 즉 나머지가 0일 경우 글자를 출력한다.\n",
    "4. num에 1을 더한다.\n",
    "\n",
    "즉 1부터 9까지 숫자 중, 짝수인 부분만 글자를 출력한다. 만일 코드가 계속해서 실행되다가 특정 조건을 만족할 경우 멈추게 하고 싶을 경우 if문에 `break`를 사용하면 된다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "id": "25efd7ed",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "잔액은 900원 입니다.\n",
      "잔액은 800원 입니다.\n",
      "잔액은 700원 입니다.\n",
      "잔액은 600원 입니다.\n",
      "잔액은 500원 입니다.\n",
      "잔액은 400원 입니다.\n",
      "잔액은 300원 입니다.\n",
      "잔액은 200원 입니다.\n",
      "잔액은 100원 입니다.\n",
      "잔액은 0원 입니다.\n"
     ]
    }
   ],
   "source": [
    "money = 1000\n",
    "\n",
    "while True:        \n",
    "    money = money - 100\n",
    "    print(f'잔액은 {money}원 입니다.')\n",
    "    \n",
    "    if money <= 0 : \n",
    "        break"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5cbde86d",
   "metadata": {},
   "source": [
    "1. money에 1000을 입력한다.\n",
    "2. `while True`를 통해 코드가 무한히 반복된다.\n",
    "3. money에서 100을 빼준 후, 잔액을 출력한다.\n",
    "4. if문을 통해 잔액이 0 미만일 경우 `break`를 통해 while문을 멈춘다.\n",
    "\n",
    "결과를 살펴보면 잔액이 100원씩 줄어들다가 0원이 된 순간, if문의 조건이 True이므로 break를 통해 while문이 멈추게 된다.\n",
    "\n",
    "### for문\n",
    "\n",
    "for문은 while문과 동일한 반복문이지만, 무한히 반복되는 것이 아닌 특정 횟수만큼만 반복되는 특징이 있다. for문의 기본적인 구조는 다음과 같다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fd680d2a",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "for 변수 in 리스트(또는 튜플, 문자열):\n",
    "    실행"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3fb9b39f",
   "metadata": {},
   "source": [
    "리스트 또는 튜플, 문자열의 첫 번째 요소부터 마지막 요소까지 차례로 변수에 대입된 후 [실행]에 해당하는 코드가 실행되며, 역시나 들여쓰기를 해야한다. 예제를 살펴보도록 하자."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "id": "bc317aa0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "var = [1, 2, 3]\n",
    "\n",
    "for i in var:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "27d53986",
   "metadata": {},
   "source": [
    "var에 해당하는 [1, 2, 3]의 리스트 중 첫 번째 요소인 1이 먼저 변수 i에 대입된 후 `print(i)`가 실행된다. 그 후 두 번째 요소인 2가 다시 변수 i에 대입되어 `print(i)`가 실행되고, 리스트의 마지막 요소까지 반복된다. \n",
    "\n",
    "for문 역시 if문과 함께 사용할 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "id": "71f10bba",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10는 짝수입니다.\n",
      "15는 홀수입니다.\n",
      "17는 홀수입니다.\n",
      "20는 짝수입니다.\n"
     ]
    }
   ],
   "source": [
    "var = [10, 15, 17, 20]\n",
    "\n",
    "for i in var:\n",
    "    if i % 2 == 0:\n",
    "        print(f'{i}는 짝수입니다.')\n",
    "    else:\n",
    "        print(f'{i}는 홀수입니다.')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4b6ecc79",
   "metadata": {},
   "source": [
    "1. var에 [10, 15, 17, 20]를 입력한다.\n",
    "2. for문을 통해 var의 요소를 하나씩 i에 대입하여 아래의 코드들을 실행한다.\n",
    "3. if문을 통해 만일 나머지가 0일 경우 '짝수입니다.'라는 글자를, 그렇지 않을 경우 else를 통해 '홀수입니다.'라는 글자를 출력한다.\n",
    "\n",
    "for문은 `range()` 함수와 함께 쓰이는 경우가 많다. `range()` 함수는 숫자(정수) 리스트를 자동으로 만들어준다. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "id": "3e3980f9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "range(0, 10)"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "range(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0838b1c2",
   "metadata": {},
   "source": [
    "`range()` 함수 내에 10을 입력할 경우 0부터 10 미만의 숫자에 해당하는 range 객체를 만들어 준다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "id": "e1e43ee1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "range(5, 10)"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "range(5, 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "23cde1e9",
   "metadata": {},
   "source": [
    "시작과 끝 숫자를 지정할 수도 있다. `range(5, 10)`을 입력하면 5부터 10 미만의 숫자에 해당하는 range 객체를 만들어 준다. `range()` 함수의 예시를 살펴보도록 하자."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "id": "d0715e21",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "for i in range(5):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "22d504e0",
   "metadata": {},
   "source": [
    "`range(5)`는 0부터 5 미만의 숫자 리스트를 의미하며, for문을 통해 요소를 하나씩 출력하였다.\n",
    "\n",
    "리스트 안에 `for`문을 포함하는 리스트 내포(List Comprehension)을 사용하면 더욱 직관적인 코딩이 가능하다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "id": "93f38307",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = [1, 2, 3]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ebdab086",
   "metadata": {},
   "source": [
    "만일 위 값들의 제곱을 구하려면 어떻게 해야할까? 일반적인 for문을 사용한 코드는 다음과 같다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "id": "d81398d7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 9]\n"
     ]
    }
   ],
   "source": [
    "result = []\n",
    "\n",
    "for i in a:\n",
    "    result.append(i**2)\n",
    "\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9f4fbf1a",
   "metadata": {},
   "source": [
    "1. 빈 리스트(result)를 만든다.\n",
    "2. i에 요소를 하나씩 입력하여 제곱(`i**2`)을 구한 후, append를 이용해 리스트에 추가한다.\n",
    "3. 결과를 확인해보면 모든 요소의 제곱이 구해졌다.\n",
    "\n",
    "그러나 리스트 내포 안에 `if` 조건을 사용하면 위 코드를 훨씬 간단하게 나타낼 수 있다. 리스트 내포의 문법은 다음과 같다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7baf77f9",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "[실행 for 변수 in 리스트(또는 튜플, 문자열)]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e16b6907",
   "metadata": {},
   "source": [
    "이는 기존의 for문에서 위아래를 변경한 후, 리스트 내에 넣어 표현한 것이다. 실제 코드로 나타내면 다음과 같다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "id": "9d564f5d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 9]\n"
     ]
    }
   ],
   "source": [
    "result = [i**2 for i in a]\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bafe2a18",
   "metadata": {},
   "source": [
    "리스트 내포를 사용할 경우 기존의 for문에 비해 훨씬 간단하게 표현할 수 있다.\n",
    "\n",
    "### 오류에 대한 예외처리\n",
    "\n",
    "for문을 실행하던 중 오류가 발생하면 작업이 끊겨 루프를 처음부터 다시 실행해야 한다. 대상이 얼마되지 않는다면 큰 문제가 되지 않겠지만, 수십분 혹은 몇시간이 걸리는 작업을 하던 중 오류가 발생해 작업을 처음부터 다시 해야하는 것은 매우 비효율적이다. `try-except`문을 이용하면 예외처리, 즉 오류가 발생할 경우 이를 무시하고 넘어갈 수 있다.\n",
    "\n",
    "try-except문의 구조는 다음과 같다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "99d819d4",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "try:\n",
    "    expr\n",
    "except:\n",
    "    error-handler-code\n",
    "else:\n",
    "    running-code\n",
    "finally:\n",
    "    cleanup-code"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3f58c10e",
   "metadata": {},
   "source": [
    "1. try 내의 `expr`는 실행하고자 하는 코드를 의미한다.\n",
    "2. except 내의 `error-handler-code`는 오류 발생 시 실행할 코드를 의미한다.\n",
    "3. else 내의 `running-code`는 expr 코드가 문제가 없을 경우 실행되는 코드, finally 내의 `cleanup-code` 코드는 오류 여부와 관계 없이 무조건 수행할 구문을 의미하며, 이 둘은 생략할 수도 있다.\n",
    "\n",
    "예제를 통해 살펴보도록 하자. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "id": "ce5ee6f8",
   "metadata": {},
   "outputs": [],
   "source": [
    "number = [1, 2, 3, \"4\", 5]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bf4028eb",
   "metadata": {},
   "source": [
    "먼저 number 변수에는 1에서 5까지 값이 입력되어 있으며, 다른 값들은 형태가 숫자인 반면 4는 문자 형태다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1f5ac05c",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "for i in number:\n",
    "    print(i ** 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "15ab44da",
   "metadata": {},
   "source": [
    "```{figure} image/python/loop_error.png\n",
    "---\n",
    "name: loop_error\n",
    "---\n",
    "```\n",
    "\n",
    "for문을 통해 순서대로 값들의 제곱을 출력하는 명령어를 실행하면 '문자 4'는 제곱을 할 수 없어 오류가 발생한다. try-except문을 사용하면 이처럼 오류가 발생하는 루프를 무시하고 다음 루프로 넘어갈 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "id": "ea4dbfb3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "4\n",
      "9\n",
      "Error at: 4\n",
      "25\n"
     ]
    }
   ],
   "source": [
    "for i in number:\n",
    "    try:\n",
    "        print(i ** 2)\n",
    "    except:\n",
    "        print('Error at: ' + i)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "75b2f5c7",
   "metadata": {},
   "source": [
    "expr 부분은 `print(i ** 2)`이며, error-handler-code 부분은 오류가 발생한 i를 출력한다. 해당 코드를 실행하면 문자 4에서 오류가 발생함을 알려준 후 루프가 멈추지 않고 다음으로 진행된다.\n",
    "\n",
    "### `tqdm()` 함수를 이용한 진행 단계 확인하기\n",
    "\n",
    "for문의 시간이 오래 걸리는 작업의 경우 어느정도 진행되었는지 궁금할 때가 있다. 파이썬에서는 tqdm 패키지를 통해 진행 정도를 손쉽게 확인할 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "id": "e8a9b9eb",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████████████████████████████████████████████████████████████████████████████| 10/10 [00:01<00:00,  9.87it/s]\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "from tqdm import tqdm\n",
    "\n",
    "for i in tqdm(range(10)):\n",
    "    time.sleep(0.1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d3633892",
   "metadata": {},
   "source": [
    "tqdm 패키지에서 `tqdm()` 함수를 불러온 뒤, for문의 loop에 해당하는 부분을 `tqdm()` 로 감싸주면, 진행 정도를 확인할 수 있다.\n",
    "\n",
    "## 함수\n",
    " \n",
    "중고등학교 수학시간에 우리는 함수라는 개념을 배웠다. $y=f(x)$라는 수식이 있을 때 $x$라는 값을 $f()$라는 함수에 입력하면 $y$라는 결과값이 나온다. 예를 들어 다음과 같은 함수가 있다고 생각해보자.\n",
    "\n",
    "$$y = 2x + 1$$\n",
    "\n",
    "만일 $x$에 1을 넣으면 결과는 $2×1 + 1 = 3$ 이며, $x$에 2를 넣으면 결과는 $2×2 + 1 = 5$ 이다.\n",
    "\n",
    "```{figure} image/python/fun.png\n",
    "---\n",
    "name: fun\n",
    "---\n",
    "함수\n",
    "```\n",
    "\n",
    "프로그래밍에서의 함수도 이와 비슷하다. 어떠한 입력값을 함수에 넣으면 이를 토대로 코드가 돌아가고, 그 결과를 반환한다. 함수를 사용하는 이유는 중복된 코드를 계속해서 작성하지 않기 위해서다. 만일 반복적으로 사용하는 코드가 있다면 이를 매번 적기 보다는 함수로 만들어두고, 필요할 때마다 함수를 사용하는 것이 효과적이다. \n",
    "\n",
    "우리는 앞서 `print()`와 같이 수많은 함수를 이미 사용했다. 이처럼 가장 이상적인 방법은 기존에 누군가 작성한 패키지 혹은 함수를 찾아 이용하는 것이지만, 그렇지 못할 경우에도 나만의 함수를 쉽게 만들어 사용할 수 있다. 파이썬에서 함수를 만드는 법은 다음과 같다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f8fe6b51",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "def f(x):\n",
    "    statement\n",
    "    return y"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6399a920",
   "metadata": {},
   "source": [
    "1. def 키워드를 통해 함수임을 선언한다.\n",
    "2. f는 함수명을 뜻한다.\n",
    "3. x는 함수에 들어가는 매개변수(Parameter)를 뜻한다.\n",
    "4. 줄을 바꾼 후 들여쓰기를 한다.\n",
    "5. statement에 해당하는 코드가 실행된다.\n",
    "6. return 뒤에 적은 y가 반환되며, 함수가 종료된다.\n",
    "\n",
    "예시로 제곱근을 계산하는 함수를 만들어보자."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "id": "1f44e884",
   "metadata": {},
   "outputs": [],
   "source": [
    "def sqrt(x):\n",
    "    res = x**(1 / 2)\n",
    "    return res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "id": "03aca3f0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.0"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sqrt(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "id": "c05ce0e1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.0"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sqrt(9)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5e69982c",
   "metadata": {},
   "source": [
    "1. def를 통해 함수를 선언하며, 함수명은 sqrt로 한다.\n",
    "2. 매개변수는 x 하나가 사용된다.\n",
    "3. x ** (1/2)은 $x^{\\frac{1}{2}}$를 뜻하며, 즉 제곱근을 구한다. 이를 res라는 변수에 저장한다.\n",
    "4. 최종적으로 res를 반환한다.\n",
    "\n",
    "만들어진 함수에 4와 9라는 숫자를 넣으면 각각의 제곱근인 2와 3을 출력된다. 참고로 함수에 입력한 4와 9처럼 함수를 호출할 때 전달하는 입력값은 인자(Argument) 혹은 인수라 한다. \n",
    "\n",
    "이번에는 매개변수가 여러개인 함수를 만들어보도록 하자."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "id": "539b6f2f",
   "metadata": {},
   "outputs": [],
   "source": [
    "def multiply(x, y):\n",
    "    res = x**y\n",
    "    return res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "id": "e3f80ec3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "81"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "multiply(x = 3, y = 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "id": "0f5ab8c2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "25"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "multiply(5, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7d9dd2a3",
   "metadata": {},
   "source": [
    "매개변수로 x와 y 두개가 사용되었으며, $x^y$를 구하는 함수인 `multiply()`를 만들었다. `multiply(x = 3, y = 4)`와 같이 각 매개변수에 대응되는 인자를 직접 지정할 수도 있지만, `multiply(5, 2)`와 같이 인자만 입력하면 함수에서 정의한 순서에 따라 x에는 5, y에는 2가 대입되어 계산이 된다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "id": "5e07ca41",
   "metadata": {},
   "outputs": [],
   "source": [
    "def divide(x, n=2):\n",
    "    res = x / n\n",
    "    return (res)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "id": "9a61cf7e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.5"
      ]
     },
     "execution_count": 123,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "divide(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "id": "0be37aea",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.0"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "divide(6, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a3d00581",
   "metadata": {},
   "source": [
    "이번에는 매개변수 부분에 `n = 2`를 통해 디폴트 값을 설정하였다. 즉 n에 해당하는 부분에 값을 입력하지 않을 경우 n에는 2라는 값이 자동으로 입력된다.\n",
    "\n",
    "위 함수에서는 매개변수가 'x', 'n' 2개가 필요함에도 불구하고 `divide(3)`은 1.5라는 값이 계산되었다. 즉 x에는 3이라는 값이 입력되었지만, n에는 값이 입력되지 않아 디폴트 값인 2가 들어갔으며, 3/2의 결과인 1.5가 계산된다. 반면 `divide(6, 3)`의 경우 n에 3이라는 값을 입력하였으므로 6/3의 결과인 2가 계산되었다.\n",
    "\n",
    "#### 람다 함수\n",
    "\n",
    "if문이나 for문을 한 줄로 간단하게 나타냈던 것과 같이, 람다(lambda)를 이용하면 간단하게 함수를 만들 수 있다. 람다의 사용법은 다음과 같다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d2af04d5",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "함수명 = lambda 매개변수1, 매개변수2, ...: statement"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fb3a31e3",
   "metadata": {},
   "source": [
    "예제로 나눗셈을 하는 함수를 람다를 통해 만들어보도록 하자."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "id": "7a00f181",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.0"
      ]
     },
     "execution_count": 125,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "divide_lam = lambda x, n: x / n\n",
    "\n",
    "divide_lam(6, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c8bb7442",
   "metadata": {},
   "source": [
    "위에서 def를 통해 만든 함수 `divide()`와 결과가 동일하다. 또한 람다를 통해 만든 함수는 return 명령어가 없어도 결괏값을 반환한다.\n",
    "\n",
    "## 패키지 사용하기\n",
    "\n",
    "패키지(package)는 기능이 비슷한 여러 함수들이 모여있는 꾸러미라고 볼 수 있으며, 파이썬이 사랑받는 이유 중 하나는 오픈 소스 생태계로 인해 다양한 패키지가 있다는 점도 크다. 전 세계의 사람들이 패키지를 만들어 온라인에 공개하고 있으며, 누구든지 이를 쉽게 다운로드 받아 사용할 수 있다. 파이썬 패키지를 공유하는 소프트웨어 저장소 PyPI(pypi.org)에는 39만개가 넘는 패키지가 공개되어 있다(2022년 8월 기준). 즉 복잡하게 코드를 짜지 않아도 기존의 패키지를 잘만 이용하면 매우 쉽게 개발 혹은 데이터 분석을 할 수 있다.\n",
    "\n",
    "아나콘다에는 사람들이 자주 쓰는 주요 패키지가 대부분 들어있으므로(2022년 8월 기준 678개), 해당 패키지들의 경우 별도의 설치 과정이 없이 바로 사용할 수 있다. 아나콘다에 들어 있는 패키지 목록은 아래 페이지에서 확인할 수 있다.\n",
    "\n",
    "```\n",
    "https://docs.anaconda.com/anaconda/packages/py3.9_win-64/\n",
    "```\n",
    "\n",
    "패키지에 있는 함수를 사용하기 위해서는 **[패키지 설치 → 패키지 불러오기 → 함수 사용]** 의 단계를 거친다. 패키지는 한 번만 설치하면 되지만, 불러오는 작업은 파이썬을 새로 열때마다 반복해야 한다. \n",
    "\n",
    "아나콘다에 포함되지 않은 패키지를 사용하기 위해서는 먼저 패키지를 설치해야 한다. 예로써 동적 크롤링에 사용되는 selenium 패키지를 설치해보도록 하자. 패키지를 설치하기 위해서는 아나콘다 프롬프트를 이용하면 된다. 윈도우의 경우 시작 메뉴를 클릭한 후 [Anaconda Prompt]를 검색한 후 실행한다.\n",
    "\n",
    "```{figure} image/quant_intro/prompt.png\n",
    "---\n",
    "name: prompt\n",
    "---\n",
    "아나콘다 프롬프트 검색 및 실행\n",
    "```\n",
    "\n",
    "프롬프트에서 `pip install 패키지명`을 입력하면 패키지를 설치한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fa553e16",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "pip install selenium"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8fa2345e",
   "metadata": {},
   "source": [
    "```{figure} image/python/selenium.png\n",
    "---\n",
    "name: selenium\n",
    "---\n",
    "selenium 패키지 다운로드\n",
    "```\n",
    "\n",
    "코드를 실행하면 파이썬 패키지 저장소 PyPI(pypi.org)에서 패키지 관련 파일을 다운로드해 하드디스크에 설치하는 과정이 프롬프트에 출력된다. 만일 패키지 설치 중 'Proceed (y/n)?' 라는 메시지가 나오면 'y'를 입력하고 엔터를 누르면 된다\n",
    "\n",
    "아나콘다에 포함되어있는 패키지 외에 본 책의 이해를 위해 추가적으로 설치해야 하는 패키지는 다음과 같다.\n",
    "\n",
    "- selenium\n",
    "- webdriver_manager\n",
    "- tiingo\n",
    "- yahoo_fin\n",
    "- xmltodict\n",
    "- pandas_datareader\n",
    "- riskfolio-lib\n",
    "- bt\n",
    "- schedule\n",
    "- yfinance\n",
    "- yahooquery\n",
    "- pandas_ta\n",
    "\n",
    "다운로드 받은 패키지를 사용하기 위해서는 이를 불러와야 한다. 패키지는 파이썬 스크립트에서 `import 패키지이름`을 통해 불러올 수 있다. 예를 들어 pandas 패키지를 불러오는 방법은 다음과 같다.\n",
    "\n",
    "```{note}\n",
    "riskfolio-lib 패키지 설치 방법은 14장에서 다시 설명하므로 이를 참조하기 바란다.\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "id": "4f29958f",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eb28312e",
   "metadata": {},
   "source": [
    "패키지 이름은 해당 패키지 내의 함수들을 사용할 때 계속해서 사용된다. 만일 패키지 이름이 너무 길면 이를 매번 입력하는것이 불편하기 때문에 `import 패키지이름 as 패키지별명` 형태로 불러올 수 있다. pandas 패키지는 일반적으로 pd로 별명을 지정한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "id": "dcda4ca6",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d4cb93b8",
   "metadata": {},
   "source": [
    "불러온 패키지 안의 내용을 살펴볼 때는 `dir(패키지이름)` 혹은 `dir(패키지별명)`을 입력한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "id": "80e65df2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['__builtins__',\n",
       " '__cached__',\n",
       " '__doc__',\n",
       " '__file__',\n",
       " '__loader__',\n",
       " '__name__',\n",
       " '__package__',\n",
       " '__path__',\n",
       " '__spec__',\n",
       " '__version__']"
      ]
     },
     "execution_count": 128,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import selenium\n",
    "dir(selenium)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "877c0395",
   "metadata": {},
   "source": [
    "많은 패키지들은 하위 패키지를 가지고 있다. 하위 패키지 중에는 상위 패키지를 불러올 때 자동으로 불러오지만 것이 있지만 그렇지 않는 것도 있다. 자동으로 불러오지 않는 하위 패키지는 다음처럼 수동으로 불러와야 한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "id": "fa77085c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Chrome',\n",
       " 'ChromeOptions',\n",
       " 'ChromeService',\n",
       " 'ChromiumEdge',\n",
       " 'DesiredCapabilities',\n",
       " 'Edge',\n",
       " 'EdgeOptions',\n",
       " 'EdgeService',\n",
       " 'Firefox',\n",
       " 'FirefoxOptions',\n",
       " 'FirefoxProfile',\n",
       " 'FirefoxService',\n",
       " 'Ie',\n",
       " 'IeOptions',\n",
       " 'IeService',\n",
       " 'Keys',\n",
       " 'Proxy',\n",
       " 'Remote',\n",
       " 'Safari']"
      ]
     },
     "execution_count": 129,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import selenium.webdriver\n",
    "dir(selenium.webdriver)[1:20]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9f34dbfd",
   "metadata": {},
   "source": [
    "패키지의 함수를 사용하기 위해서는 `패키지이름.함수()` 혹은 `패키지별명.함수()`를 입력한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "id": "47018056",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>sepal_length</th>\n",
       "      <th>sepal_width</th>\n",
       "      <th>petal_length</th>\n",
       "      <th>petal_width</th>\n",
       "      <th>species</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>5.1</td>\n",
       "      <td>3.5</td>\n",
       "      <td>1.4</td>\n",
       "      <td>0.2</td>\n",
       "      <td>setosa</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>4.9</td>\n",
       "      <td>3.0</td>\n",
       "      <td>1.4</td>\n",
       "      <td>0.2</td>\n",
       "      <td>setosa</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>4.7</td>\n",
       "      <td>3.2</td>\n",
       "      <td>1.3</td>\n",
       "      <td>0.2</td>\n",
       "      <td>setosa</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>4.6</td>\n",
       "      <td>3.1</td>\n",
       "      <td>1.5</td>\n",
       "      <td>0.2</td>\n",
       "      <td>setosa</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>5.0</td>\n",
       "      <td>3.6</td>\n",
       "      <td>1.4</td>\n",
       "      <td>0.2</td>\n",
       "      <td>setosa</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>145</th>\n",
       "      <td>6.7</td>\n",
       "      <td>3.0</td>\n",
       "      <td>5.2</td>\n",
       "      <td>2.3</td>\n",
       "      <td>virginica</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>146</th>\n",
       "      <td>6.3</td>\n",
       "      <td>2.5</td>\n",
       "      <td>5.0</td>\n",
       "      <td>1.9</td>\n",
       "      <td>virginica</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>147</th>\n",
       "      <td>6.5</td>\n",
       "      <td>3.0</td>\n",
       "      <td>5.2</td>\n",
       "      <td>2.0</td>\n",
       "      <td>virginica</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>148</th>\n",
       "      <td>6.2</td>\n",
       "      <td>3.4</td>\n",
       "      <td>5.4</td>\n",
       "      <td>2.3</td>\n",
       "      <td>virginica</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>149</th>\n",
       "      <td>5.9</td>\n",
       "      <td>3.0</td>\n",
       "      <td>5.1</td>\n",
       "      <td>1.8</td>\n",
       "      <td>virginica</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>150 rows × 5 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "     sepal_length  sepal_width  petal_length  petal_width    species\n",
       "0             5.1          3.5           1.4          0.2     setosa\n",
       "1             4.9          3.0           1.4          0.2     setosa\n",
       "2             4.7          3.2           1.3          0.2     setosa\n",
       "3             4.6          3.1           1.5          0.2     setosa\n",
       "4             5.0          3.6           1.4          0.2     setosa\n",
       "..            ...          ...           ...          ...        ...\n",
       "145           6.7          3.0           5.2          2.3  virginica\n",
       "146           6.3          2.5           5.0          1.9  virginica\n",
       "147           6.5          3.0           5.2          2.0  virginica\n",
       "148           6.2          3.4           5.4          2.3  virginica\n",
       "149           5.9          3.0           5.1          1.8  virginica\n",
       "\n",
       "[150 rows x 5 columns]"
      ]
     },
     "execution_count": 130,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import seaborn as sns\n",
    "\n",
    "iris = sns.load_dataset('iris')\n",
    "iris"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "24e37f31",
   "metadata": {},
   "source": [
    "먼저 seaborn 패키지를 sns라는 별명으로 불러온 후, 데이터셋을 불러오는 함수인 `load_dataset()`을 이용해 'iris' 데이터셋을 불러왔다.\n",
    "\n",
    "패키지를 불러올때 모든 함수를 불러오는 것이 아닌 특정 함수만 선택해서 불러올 수도 있다. 이는 `from 패키지이름 import 함수` 혹은 `from 패키지이름 import 함수1, 함수2, 함수3` 형태로 불러온다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "id": "b12e1934",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>sepal_length</th>\n",
       "      <th>sepal_width</th>\n",
       "      <th>petal_length</th>\n",
       "      <th>petal_width</th>\n",
       "      <th>species</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>5.1</td>\n",
       "      <td>3.5</td>\n",
       "      <td>1.4</td>\n",
       "      <td>0.2</td>\n",
       "      <td>setosa</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>4.9</td>\n",
       "      <td>3.0</td>\n",
       "      <td>1.4</td>\n",
       "      <td>0.2</td>\n",
       "      <td>setosa</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>4.7</td>\n",
       "      <td>3.2</td>\n",
       "      <td>1.3</td>\n",
       "      <td>0.2</td>\n",
       "      <td>setosa</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>4.6</td>\n",
       "      <td>3.1</td>\n",
       "      <td>1.5</td>\n",
       "      <td>0.2</td>\n",
       "      <td>setosa</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>5.0</td>\n",
       "      <td>3.6</td>\n",
       "      <td>1.4</td>\n",
       "      <td>0.2</td>\n",
       "      <td>setosa</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>145</th>\n",
       "      <td>6.7</td>\n",
       "      <td>3.0</td>\n",
       "      <td>5.2</td>\n",
       "      <td>2.3</td>\n",
       "      <td>virginica</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>146</th>\n",
       "      <td>6.3</td>\n",
       "      <td>2.5</td>\n",
       "      <td>5.0</td>\n",
       "      <td>1.9</td>\n",
       "      <td>virginica</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>147</th>\n",
       "      <td>6.5</td>\n",
       "      <td>3.0</td>\n",
       "      <td>5.2</td>\n",
       "      <td>2.0</td>\n",
       "      <td>virginica</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>148</th>\n",
       "      <td>6.2</td>\n",
       "      <td>3.4</td>\n",
       "      <td>5.4</td>\n",
       "      <td>2.3</td>\n",
       "      <td>virginica</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>149</th>\n",
       "      <td>5.9</td>\n",
       "      <td>3.0</td>\n",
       "      <td>5.1</td>\n",
       "      <td>1.8</td>\n",
       "      <td>virginica</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>150 rows × 5 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "     sepal_length  sepal_width  petal_length  petal_width    species\n",
       "0             5.1          3.5           1.4          0.2     setosa\n",
       "1             4.9          3.0           1.4          0.2     setosa\n",
       "2             4.7          3.2           1.3          0.2     setosa\n",
       "3             4.6          3.1           1.5          0.2     setosa\n",
       "4             5.0          3.6           1.4          0.2     setosa\n",
       "..            ...          ...           ...          ...        ...\n",
       "145           6.7          3.0           5.2          2.3  virginica\n",
       "146           6.3          2.5           5.0          1.9  virginica\n",
       "147           6.5          3.0           5.2          2.0  virginica\n",
       "148           6.2          3.4           5.4          2.3  virginica\n",
       "149           5.9          3.0           5.1          1.8  virginica\n",
       "\n",
       "[150 rows x 5 columns]"
      ]
     },
     "execution_count": 131,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from seaborn import load_dataset\n",
    "load_dataset('iris')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6b1ab182",
   "metadata": {},
   "source": [
    "이번에는 seaborn 패키지에서 `load_dataset()` 함수만 불러왔다. 이처럼 특정 함수만 불러온 경우, 함수명 앞에 패키지이름을 붙여주지 않아도 함수가 작동한다. 만일 한번에 모든 함수를 불러오고 싶을 때는 `from 패키지이름 import *` 를 입력하면 된다.\n",
    "\n",
    "### 함수와 메서드의 차이\n",
    "\n",
    "파이썬 관련 책을 살펴보면 똑같이 `something()` 형태로 생겼지만 어떤 것은 함수, 어떤 것은 메서드라 불린다. 먼저 함수는 특정 기능을 수행하는 역할을 하며, 각 함수마다 나름의 기능을 가지고 있다. 예를 들어 파이썬의 내장 함수인 `sum()`은 합계를 구한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "id": "b425be03",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 132,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum([1, 2])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a855f2c1",
   "metadata": {},
   "source": [
    "특정 패키지에서 제공하는 함수도 있다. pandas의 `DataFrame()` 함수는 데이터프레임을 만드는 역할을 한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "id": "bf72da87",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>x</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   x\n",
       "0  1\n",
       "1  2\n",
       "2  3"
      ]
     },
     "execution_count": 133,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "df = pd.DataFrame({'x' : [1,2,3]})\n",
    "\n",
    "df"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0e45566d",
   "metadata": {},
   "source": [
    "반면 메서드는 클래스 및 객체와 연관되어 있는 함수다. `info()` 메서드는 위에서 만든 데이터프레임 객체의 정보를 보여준다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "id": "37fb24ce",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pandas.core.frame.DataFrame'>\n",
      "RangeIndex: 3 entries, 0 to 2\n",
      "Data columns (total 1 columns):\n",
      " #   Column  Non-Null Count  Dtype\n",
      "---  ------  --------------  -----\n",
      " 0   x       3 non-null      int64\n",
      "dtypes: int64(1)\n",
      "memory usage: 156.0 bytes\n"
     ]
    }
   ],
   "source": [
    "df.info()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cacfaa8e",
   "metadata": {},
   "source": [
    "각 객체 혹은 자료 구조에 따라 사용할 수 있는 메서드가 다르다. `info()` 메서드는 데이터프레임에는 사용할 수 있지만, 리스트 객체에는 사용할 수 없다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d4ca84e1",
   "metadata": {
    "deletable": false,
    "editable": false,
    "run_control": {
     "frozen": true
    }
   },
   "outputs": [],
   "source": [
    "lst = [1,2,3]\n",
    "lst.info()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e5f57dcc",
   "metadata": {},
   "source": [
    "```{figure} image/quant_intro/list_error.png\n",
    "---\n",
    "name: list_error\n",
    "---\n",
    "```\n",
    "\n",
    "위 코드를 실행하면 **AttributeError: 'list' object has no attribute 'info'** 라는 에러가 뜬다. list 객체는 `info()` 매서드를 보유하고 있지 않아 에러가 발생하는 것이다. 즉 함수는 `sum()`, `pd.DataFrame()`과 같이 독립적으로 사용되는 반면, 메서드는 a라는 특정 객체가 존재할 때 `a.head()`, `a.info()`와 같은 형태로 사용된다."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.11.5"
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}