python/Day01_파이썬기초.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"font-size: 33px; font-weight: 700; margin-bottom: 3rem\">Python 기초 I</p>\n",
    "\n",
    "# 개요\n",
    "\n",
    "본 강의 자료는 [Python 공식 Tutorial](https://docs.python.org/3/tutorial/index.html)에 근거하여 만들어졌으며, Python 3.9 이상 버전에 해당하는 내용을 담고 있습니다.\n",
    "\n",
    "또한, 파이썬에서 제공하는 스타일 가이드인 [`PEP-8`](https://www.python.org/dev/peps/pep-0008/) 내용을 반영하였습니다. \n",
    "\n",
    "파이썬을 활용하는 다양한 IT기업들은 대내외적으로 본인들의 스타일 가이드를 제공하고 있습니다. \n",
    "\n",
    "* [구글 스타일 가이드](https://github.com/google/styleguide/blob/gh-pages/pyguide.md)\n",
    "* [Tensorflow 스타일 가이드](https://www.tensorflow.org/community/contribute/code_style?hl=ko)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 기초 문법(Syntax)\n",
    "## 들여쓰기(Indentation)\n",
    "\n",
    "코드 블록을 구분할 때, 중괄호 ({,}) 대신 <들여쓰기 (identation)>를 사용합니다.\n",
    "\n",
    "들여쓰기를 할 때는 4칸(space키 4번) 혹은 1탭 (Tab키 1번)을 입력합니다.\n",
    "- 주의! 한 코드 안에서는 반드시 한 종류의 들여쓰기를 사용합니다.\n",
    "- 원칙적으로는 공백 (빈칸, space) 사용을 권장합니다. * PEP8 권장사항"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 일반적인 코드 작성 스타일"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('hello')\n",
    "print('world')\n",
    "\n",
    "a = 'apple'\n",
    "\n",
    "if True:\n",
    "    print(True)\n",
    "else:\n",
    "    print(False)\n",
    "\n",
    "b = 'banana'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 변수(Variable)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 변수 \n",
    "컴퓨터 메모리 어딘가에 저장되어 있는 객체를 참조하기 위해 사용되는 이름을 의미합니다.\n",
    "- 객체(object) : 숫자, 문자, 클래스 등 **값을 가지고 있는 모든 것**을 말합니다.\n",
    "    - 파이썬은 객체지향 언어이며, 모든 것이 객체로 구현되어 있습니다.\n",
    "- 동일 변수에 다른 객체를 언제든 할당할 수 있습니다.\n",
    "    - 즉, 참조하는 객체가 바뀔 수 있기 때문에 '변수' 라고 부릅니다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<center><img src=\"https://user-images.githubusercontent.com/18046097/61179855-0c8d0200-a646-11e9-9e9e-2c6df0504296.png\", alt=\"variable\"/></center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "<center><img src=\"https://user-images.githubusercontent.com/18046097/61179857-13b41000-a646-11e9-9a88-8487df4eaf52.png\", alt=\"box\"/></center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 할당 연산자(Assignment Operator): `=`\n",
    "\n",
    "* 변수는 `=`을 통해 할당(assignment) 됩니다. \n",
    "\n",
    "* 해당 데이터 타입을 확인하기 위해서는 `type()`을 활용합니다.\n",
    "\n",
    "* 해당 값의 메모리 주소를 확인하기 위해서는 `id()`를 활용합니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 변수 x에 임의의 문자열을 할당해봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# type(x)를 실행하여 변수 x에 할당된 값의 데이터 타입을 확인해 봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# id(x)를 실행하여 변수 x의 고유 메모리 주소를 확인해봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 변수 연산"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# i, j, s 변수에 각각 5, 3, '파이썬'을 할당해봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 변수 i와 j를 더해봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 변수 i에 i - j를 할당해봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 변수 j에 -2를 할당하고 i * j를 실행해봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# i * j / 3 을 실행하여 결과를 확인해봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 문자열 '안녕'과 변수 s를 더해봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 변수 s에 s * 3을 할당하고 결과를 확인해봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 변수 s에 문자열 'Python'을 할당하고\n",
    "# s + ' is fun'을 실행하여 결과를 확인해봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 변수 할당\n",
    "* 같은 값을 동시에 할당할 수 있습니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 같은 값을 x와 y에 동시에 할당해봅시다.\n",
    "# 그리고 print를 이용하여 x, y 값을 확인해봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 다른 값을 동시에 할당 가능합니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 두 개의 변수 x, y에 값 1, 2를 동시에 할당해봅시다.\n",
    "# 그리고 print를 이용하여 x, y 값을 확인해봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 두 개의 변수 x, y에 값 1을 할당해봅시다.\n",
    "# 두 개의 변수에 하나의 값을 할당했을 때의 오류를 확인해봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 두 개의 변수 x, y에 값 1, 2, 3을 동시에 할당해봅시다.\n",
    "# 두 개의 변수에 세 개의 값을 할당했을 때의 오류를 확인해봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 실습 문제\n",
    "- x = 10, y = 20 일 때, 각각 값을 바꿔서 저장하는 코드를 작성하세요."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x, y = 10, 20"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 변수 x와 y의 값을 바꿔봅시다.\n",
    "# 그리고 결과를 print를 이용해 확인해봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 방법1 : 임시 변수 활용"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 방법 2 : Pythonic"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 참고 - 사용자 입력(input)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "input([prompt])\n",
    "* 사용자로부터 값을 즉시 입력 받을 수 있는 파이썬 내장함수입니다.\n",
    "* 대괄호([]) 안에 문자열을 입력하면 해당 문자열을 출력할 수 있습니다.\n",
    "    - 단, 대괄호는 생략합니다.\n",
    "    ```python\n",
    "    # ex)\n",
    "    input('값을 입력해 주세요. : ')\n",
    "    ```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# input()을 사용해 봅시다.\n",
    "# data 변수에 input()의 반환값을 할당합니다.\n",
    "# print 함수를 이용하여 data 변수에 담긴 값을 출력해 봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 문자열 '이름을 입력 해 주세요. : '를 출력하는 input 함수를 변수 name에 할당합니다.\n",
    "# print 함수를 이용하여 name 변수에 담긴 값을 출력해 봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 반환값은 항상 문자열의 형태로 반환됩니다.\n",
    "\n",
    "```python\n",
    ">>> num = input('숫자를 입력 해 주세요. : ')\n",
    "숫자를 입력 해 주세요. : 100\n",
    "    \n",
    ">>> print(num)\n",
    "'100'\n",
    "\n",
    ">>> print(type(num))\n",
    "<class 'str'>\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# input()으로 입력 받은 값의 type을 출력해 봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 식별자(Identifiers)\n",
    "\n",
    "파이썬에서 식별자는 변수, 함수, 모듈, 클래스 등을 식별하는데 사용되는 이름(name)입니다. \n",
    "\n",
    "* 식별자의 이름은 영문 알파벳(대문자와 소문자), 언더스코어(_), 숫자로 구성됩니다.\n",
    "* 첫 글자에 숫자가 올 수 없습니다.\n",
    "* 길이에 제한이 없습니다.\n",
    "* 대/소문자(case)를 구별합니다.\n",
    "* 아래의 키워드는 사용할 수 없습니다. [파이썬 문서](https://docs.python.org/ko/3/reference/lexical_analysis.html#keywords)\n",
    "\n",
    "```\n",
    "False, None, True, and, as, assert, async, await, break, class, continue, def, del, elif, else, except, finally, for, from, global, if, import, in, is, lambda, nonlocal, not, or, pass, raise, return, try, while, with, yield\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 키워드들을 직접 확인해봅시다.\n",
    "# import 구문을 사용하여 keyword를 불러옵니다.\n",
    "# print를 이용하여 파이썬이 가지고 있는 키워드 / 예약어를 출력해봅시다.\n",
    "# import 구문에 대한 자세한 내용은 모듈 챕터에서 학습하겠습니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import keyword\n",
    "print(keyword.kwlist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*  내장함수나 모듈 등의 이름으로도 만들면 안됩니다.\n",
    "- 기존의 이름에 다른 값을 할당하게 되므로 더 이상 동작하지 않게됩니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 내장함수의 이름을 사용하면 어떤일이 일어나는지 확인해봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# print는 값을 출력해주는 내장함수(Built-in function)입니다.\n",
    "# print(5)를 실행하여 결과를 확인해봅시다.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 변수 print에 문자열 'hi'를 할당합니다. \n",
    "# 그리고 print() 를 사용하였을때 발생하는 오류를 확인해봅시다.\n",
    "# print는 'hi'라는 값을 가지는 변수로 할당되었기 때문에 이전의 출력 기능을 수행하지 못합니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print = 'hi'\n",
    "print(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 뒤에서 진행될 코드에 영향이 갈 수 있기 때문에 방금 생성한 print 변수를 삭제합니다.\n",
    "# 아래와 같이 del 연산자를 활용합니다.\n",
    "# del print\n",
    "# 사용자가 지정한 변수 print는 삭제되고, 기존의 화면출력 기능을 가지는 print가 동작합니다.\n",
    "# 자세한 내용은 namespace 파트에서 확인해봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "del print"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 주석(Comment)\n",
    "\n",
    "* 한 줄 주석은 `#`으로 표현합니다. \n",
    "\n",
    "* 여러 줄의 주석은 \n",
    "    1. 한 줄 씩 `#`을 사용해서 표현하거나,\n",
    "    2. `\"\"\"` 또는 `'''`(여러줄 문자열, multiline string)으로 표현할 수 있습니다.\n",
    "    (multiline은 주로 함수/클래스를 설명(docstring)하기 위해 활용됩니다.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# print('hello') # 이 줄은 실행되지 않습니다.\n",
    "print('world')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 여러줄 주석을 multiline string을 활용하여 연습해봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "이것은\n",
    "여러줄에 걸친\n",
    "주석을 만드는 코드입니다.\n",
    "\"\"\"\n",
    "print('world')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 연산자(Operator)\n",
    "\n",
    "- 산술 연산자(Arithmetic Operator)\n",
    "- 비교 연산자(Comparison Operator)\n",
    "- 논리 연산자(Logical Operator)\n",
    "- 복합 연산자(In-place Operator)\n",
    "- 멤버십 연산자(Membership Operator)\n",
    "- 식별 연산자(Identity Operator)\n",
    "- 기타 (Indexing/Slicing)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 산술 연산자 (Arithmetic Operator)\n",
    "Python에서는 기본적인 사칙연산이 가능합니다. \n",
    "\n",
    "|연산자|내용|\n",
    "|----|---|\n",
    "|+|덧셈|\n",
    "|-|뺄셈|\n",
    "|\\*|곱셈|\n",
    "|/|나눗셈|\n",
    "|//|몫|\n",
    "|%|나머지(modulo)|\n",
    "|\\*\\*|거듭제곱|\n",
    "\n",
    "- 나눗셈 (`/`) 은 항상 float를 돌려줍니다.\n",
    "- 정수 나눗셈 으로 (소수부 없이) 정수 결과를 얻으려면 `//` 연산자를 사용합니다.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 2의 1000승을 확인해봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 나눗셈과 관련된 산술연산자를 활용해봅시다.\n",
    "# 5와 2를 나눈 값을 출력해봅시다.\n",
    "# 5와 2를 나눈 값의 몫을 출력해봅시다.\n",
    "# 5와 2를 나눈 값을 integer로 형변환해봅시다.\n",
    "# 5와 2를 나눈 값의 나머지를 출력해봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# divmod는 나눗셈과 관련된 함수입니다.\n",
    "# divmode() 에 5와 2를 넣고 결과를 print로 확인해봅시다.\n",
    "# 변수 quotient, remainder 에 divmode(5, 2)의 값을 할당해봅시다.\n",
    "# f-string을 활용하여 quorient와 remainder의 값을 출력해봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 음수 양수 표현도 해봅시다.\n",
    "# 변수 positive_num 에 4를 할당하고 print할 때 -를 붙여서 print로 출력해봅시다.\n",
    "# 변수 negative_num 에 -4를 할당하고 print할 때 + 와 - 를 붙여서 각각을 print로 출력해봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 연산자 우선순위\n",
    "\n",
    "0. `()`을 통한 grouping\n",
    "\n",
    "1. Slicing\n",
    "\n",
    "2. Indexing\n",
    "\n",
    "3. 제곱연산자\n",
    "    `**`\n",
    "\n",
    "4. 단항연산자 \n",
    "    `+`, `-` (음수/양수 부호)\n",
    "\n",
    "5. 산술연산자\n",
    "    `*`, `/`, `%`\n",
    "    \n",
    "6. 산술연산자\n",
    "    `+`, `-`\n",
    "    \n",
    "7. 비트 연산자 \n",
    "8. 비교연산자\n",
    "9. 식별 연산자 \n",
    "10. 논리 연산자\n",
    "\n",
    "[파이썬 문서](https://docs.python.org/ko/3/reference/expressions.html#operator-precedence)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 우선순위를 확인해봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# -3 ** 6의 값을 확인해봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# (-3) ** 6의 값을 확인해봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 자료형(Data Type)\n",
    "\n",
    "## 자료형 분류\n",
    "- **불린형**(Boolean Type)\n",
    "- **수치형**(Numeric Type)\n",
    "    - int (정수, integer)\n",
    "    - float (부동소수점, 실수, floating point number)\n",
    "- **문자열**(String Type)\n",
    "- **None**\n",
    "    - 값이 없음을 표현하기 위한 타입\n",
    "\n",
    "\n",
    "<img width=\"634\" alt=\"자료형\" src=\"https://user-images.githubusercontent.com/45934087/148158891-fe28256b-1df4-4b83-ab51-54d06c107d20.png\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 수치형(Numeric Type)\n",
    "[파이썬 문서](https://docs.python.org/ko/3/library/stdtypes.html#numeric-types-int-float-complex)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  `int` (정수, ingteger)\n",
    "\n",
    "모든 정수는 `int`로 표현됩니다.\n",
    "\n",
    "Python3에서는 `long` 타입은 없고 모두 `int` 타입으로 표기 됩니다.\n",
    "\n",
    "* 보통 프로그래밍 언어 및 Python2에서의 long은 OS 기준 32/64비트입니다.\n",
    "* Python3에서는 모두 int로 통합되었습니다.\n",
    "\n",
    "8진수 : `0o` / 2진수 : `0b` / 16진수: `0x` 로도 표현 가능합니다. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 변수 a에 정수 3을 할당하고 해당 변수의 type을 알아봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 변수 a에 2의 64제곱을 할당합니다.\n",
    "# print와 type을 이용하여 a의 값과 타입을 확인해봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**파이썬에서 표현할 수 있는 가장 큰 수**\n",
    "* 파이썬에서 가장 큰 숫자를 활용하기 위해 sys 모듈을 불러옵니다.\n",
    "* 파이썬은 기존 C 계열 프로그래밍 언어와 다르게 정수 자료형(integer)에서 오버플로우가 없습니다.\n",
    "* 임의 정밀도 산술(arbitrary-precision arithmetic)을 사용하기 때문입니다. \n",
    "\n",
    "> **오버플로우(overflow)**\n",
    "- 데이터 타입 별로 사용할 수 있는 메모리의 크기가 제한되어 있습니다.\n",
    "- 표현할 수 있는 수의 범위를 넘어가는 연산을 하게 되면, 기대했던 값이 출력되지 않는 현상, 즉 메모리를 넘어선 상황을 의미합니다.\n",
    "\n",
    "> **임의 정밀도 산술(arbitrary-precision arithmetic)**\n",
    "- 사용할 수 있는 메모리양이 정해져 있는 기존의 방식과 달리, 현재 남아있는 만큼의 가용 메모리를 모두 수 표현에 끌어다 쓸 수 있는 형태를 의미합니다.\n",
    "- 특정 값을 나타내는데 4바이트가 부족하다면 5바이트, 더 부족하면 6바이트까지 사용할 수 있게 유동적으로 운용합니다.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 파이썬이 얼만큼 큰 숫자까지 저장할 수 있는지 확인해봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "max_int = sys.maxsize\n",
    "# sys.maxsize 의 값은 2**63 - 1 => 64비트에서 부호비트를 뺀 63개의 최대치\n",
    "print(max_int)\n",
    "super_max = sys.maxsize * sys.maxsize\n",
    "print(super_max)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# n진수를 만들어봅시다.\n",
    "# 2진수는 변수 binary_number에 0b10을 할당합니다.\n",
    "# 8진수는 변수 octal_number에 0o10을 할당합니다.\n",
    "# 10진수는 변수 decimal_number에 10을 할당합니다.\n",
    "# 16진수는 변수 hexadecimal_number에 0x10을 할당합니다.\n",
    "# 각 변수를 print를 이용해서 여러줄로 출력해봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "binary_number = 0b10\n",
    "octal_number = 0o10\n",
    "decimal_number = 10\n",
    "hexadecimal_number = 0x10\n",
    "print(f\"\"\"2진수 : {binary_number}\n",
    "8진수 : {octal_number}\n",
    "10진수 : {decimal_number}\n",
    "16진수 : {hexadecimal_number}\n",
    "\"\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `float` (부동소수점, 실수, floating point number)\n",
    "\n",
    "실수는 `float`로 표현됩니다. \n",
    "\n",
    "다만, 실수를 컴퓨터가 표현하는 과정에서 부동소수점을 사용하며, 항상 같은 값으로 일치되지 않습니다. (floating point rounding error)\n",
    "\n",
    "이는 컴퓨터가 2진수(비트)를 통해 숫자를 표현하는 과정에서 생기는 오류이며, 대부분의 경우는 중요하지 않으나 값이 같은지 비교하는 과정에서 문제가 발생할 수 있습니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 변수 a에 실수 3.5를 할당하고 해당 변수의 type을 알아봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 컴퓨터식 지수 표현 방식\n",
    "* e를 사용할 수도 있습니다. (e와 E 모두 사용 가능)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 컴퓨터식 지수 표현 방식을 사용해봅시다.\n",
    "# 변수 b에 지수 314e-2를 할당하고 해당 변수의 type을 알아봅시다.\n",
    "# print를 이용해 변수 b의 값도 알아봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 실수의 연산\n",
    "* 실수의 경우 실제로 값을 처리하기 위해서는 조심할 필요가 있습니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실수의 덧셈을 해봅시다.\n",
    "# 실수 두 개를 더해봅시다. (3.5 + 3.2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실수의 뺄셈을 해봅시다. (3.5 - 3.12)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 우리가 원하는대로 반올림을 해봅시다.\n",
    "# round() 는 0~4는 내림, 5는 동일하게 작동하지 않고 반올림 방식에 따라 다릅니다.\n",
    "# 짝수에서 5는 내림 / 홀수에서 5는 올림\n",
    "# round(값, 소수점자릿수)\n",
    "# 3.5 - 3.12 의 값을 반올림하는데 소수점 2자리까지 나타나게 해봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 3.5 - 3.12의 결과와 0.38의 값이 같은지 == 을 사용해서 확인해봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# print를 이용해서 3.5 - 3.12의 값을 확인해 봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 따라서 다음과 같은 방법으로 처리 할 수 있습니다. (이외에 다양한 방법이 있음)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 1. 기본적인 처리방법을 알아봅시다.\n",
    "# 변수 a, b에 각각의 실수 값을 저장합니다.\n",
    "# 그리고 abs()를 이용하여 a와 b의 차이를 구합니다.\n",
    "# a와 b의 차이가 1e-10 값 이하이면 a 와 b 는 같다고 볼 수 있습니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 3.5 - 3.12\n",
    "b = 0.38\n",
    "\n",
    "abs(a - b) <= 1e-10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 2. sys 모듈을 통해 처리하는 방법을 알아봅시다.\n",
    "# `epsilon` 은 부동소수점 연산에서 반올림을 함으로써 발생하는 오차 상환\n",
    "# abs() 를 이용하여 a, b의 차이를 구합니다.\n",
    "# a와 b의 차이가 sys.float_info.epsilon의 값 이하이면 a, b 는 같다고 볼 수 있습니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "abs(a - b) <= sys.float_info.epsilon"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 3. python 3.5부터 활용 가능한 math 모듈을 통해 처리하는 법을 알아봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# math.isclose() 를 이용해서 a와 b의 값이 같은지 확인할수 있습니다.\n",
    "import math\n",
    "math.isclose(a, b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 문자열 (String Type)\n",
    "\n",
    "### 문자열\n",
    "- 모든 문자는 `str` 로 표현됩니다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 기본 활용법\n",
    "\n",
    "* 문자열은 Single quotes(`'`)나 Double quotes(`\"`)을 활용하여 표현 가능합니다.\n",
    "\n",
    "* 단, 문자열을 묶을 때 동일한 문장부호를 활용해야하며, `PEP-8`에서는 **하나의 문장부호를 선택**하여 유지하도록 하고 있습니다. \n",
    "(Pick a rule and Stick to it)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 문자열 hello 를 출력해 봅시다.\n",
    "# 문자열 hello의 타입을 출력해 봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 문자열 철수 '안녕' 을 출력해 봅시다.\n",
    "# 문자열 철수 \"안녕\" 을 출력해 봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 변수에 문자열을 할당하고 출력해봅시다.\n",
    "# 변수 greeting 에 hi를 name 에 'ssafy'를 할당합시다. \n",
    "# 그리고 각각의 변수를 print로 찍어보고 type도 확인해봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 변수 age 에 사용자로 부터 입력을 받을 수 있는 input()의 결과를 저장합시다.\n",
    "# age 에 입력받은 값이 저장되었는지 그리고 그 type이 무엇인지 확인해봅시다.\n",
    "# 숫자를 할당했을때와 문자를 할당했을때의 type이 같은지 다른지도 확인해봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Immutable\n",
    "\n",
    "문자열을 변경할 수 없음"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 'my string?'\n",
    "a[-1] = '!'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Iterable\n",
    "\n",
    "문자열을 순회 가능함"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = '123'\n",
    "for char in a:\n",
    "    print(char)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 중첩 따옴표 (Nested Quotes)\n",
    "따옴표 안에 따옴표를 표현할 경우 아래와 같이 사용할 수 있습니다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 작은따옴표: `'\"큰\" 따옴표를 담을 수 있습니다'`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('문자열 안에 \"작은 따옴표\"를 사용하려면 큰 따옴표로 묶는다.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 큰따옴표: `\"'작은' 따옴표를 담을 수 있습니다\"`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"문자열 안에 '작은 따옴표'를 사용하려면 큰 따옴표로 묶는다.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 삼중 따옴표 (Triple Quotes)\n",
    "작은 따옴표나 큰 따옴표를 삼중으로 사용합니다.\n",
    "\n",
    "- 문자열 안에 따옴표를 넣을 때 사용합니다.\n",
    "\n",
    "- 여러줄에 걸쳐있는 문장은 다음과 같이 표현 가능합니다.\n",
    "\n",
    "* `PEP-8`에 따르면 이 경우에는 반드시 `\"\"\"`를 사용하도록 규정합니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 아래 작성된 내용을 삼중 따옴표와 하나의 print 문을 사용하여 출력해 봅시다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "문자열 안에 '작은 따옴표'나\n",
    "\n",
    "\"큰 따옴표\"를 사용할 수 있고\n",
    "\n",
    "여러 줄을 사용할 때도 편리하다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"\"\"\n",
    "개행문자 없이\n",
    "여러 줄을 그대로 출력 가능합니다.\n",
    "\"\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 이스케이프 시퀀스 (Escape sequence)\n",
    "\n",
    "문자열을 활용하는 경우 특수문자 혹은 조작을 하기 위하여 사용되는 것으로 역슬래시 `\\`를 활용하여 이를 구분합니다. \n",
    "\n",
    "|<center>예약문자</center>|내용(의미)|\n",
    "|:--------:|:--------:|\n",
    "|\\n|줄 바꿈|\n",
    "|\\t|탭|\n",
    "|\\r|캐리지리턴|\n",
    "|\\0|널(Null)|\n",
    "|\\\\\\\\ |`\\`|\n",
    "|\\\\'|단일인용부호(`'`)|\n",
    "|\\\\\"|이중인용부호(`\"`)|"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 다음 문자열을 작은 따옴표와 escape sequence만을 사용하여 출력해 봅시다.\n",
    "# 철수야 '안녕'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('철수야 \\'안녕\\'')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 다음 문자열을 하나의 print 함수에서 출력해 봅시다.\n",
    "# escape sequence를 이용합니다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "이 다음은 엔터.\n",
    "그리고 탭    탭"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('이 다음은 엔터. \\n그리고 탭\\t탭')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### String interpolation \n",
    "\n",
    "* `%-formatting` \n",
    "\n",
    "    * `%d` : 정수\n",
    "    \n",
    "    * `%f` : 실수\n",
    "    \n",
    "    * `%s` : 문자열\n",
    "\n",
    "* [`str.format()` ](https://pyformat.info/)\n",
    "\n",
    "* [`f-strings`](https://www.python.org/dev/peps/pep-0498/) : 파이썬 3.6 이후 버전에서 지원"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# name 변수에 이름, score 변수에 학점을 할당해봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "name = 'Kim'\n",
    "score = 4.5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# %-formatting 은 다음과 같이 사용합니다.\n",
    "print('Hello, %s' % name)\n",
    "print('내 성적은 %d' % score)\n",
    "print('내 성적은 %f' % score)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# str.format()은 다음과 같이 사용합니다.\n",
    "print('Hello, {}'.format(name))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# str.format()을 활용해봅시다.\n",
    "# score를 출력해봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# f-string을 활용해봅시다.\n",
    "# name 을 출력해봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 여러줄 문자열에서도 사용 가능합니다.\n",
    "# f-string을 이용하여 name을 여러줄 문자열로 출력해봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(f\"\"\"\n",
    "Hello,\n",
    "{name}\n",
    "\"\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* f-strings에서는 형식을 지정할 수 있습니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 다양한 형식을 활용하기 위해 datetime 모듈로 오늘을 표현해봅시다.\n",
    "# today 에 현재 시간 날짜를 할당해봅시다.\n",
    "# print를 이용하여 today를 출력해봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import datetime\n",
    "today = datetime.datetime.now()\n",
    "print(today)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# interpolation에서 출력형식을 지정할 수 있습니다.\n",
    "# today에 저장된 시간을 YYYY년, mm월, dd일, a요일 로 구분해서 출력해봅시다.\n",
    "# 각각 %y, %m, %A를 사용합니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(f'오늘은 {today:%y}년 {today:%m}월 {today:%d}일 {today:%A}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* f-strings에서는 연산과 출력형식 지정도 가능합니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# string interpolation을 통해 출력형식 지정 뿐만 아니라, 연산도 가능합니다.\n",
    "# pi = 3.141592를 할당하고 \n",
    "# 원주율은 3.14. 반지를이 2일 때 원의 넓이는 12.566368이라고 출력해봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## None Type\n",
    "\n",
    "파이썬에서는 값이 없음을 표현하기 위해 `None` 타입이 존재합니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# None의 타입을 알아봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 변수에 저장해서 확인해봅시다.\n",
    "# 변수 a에 None을 할당하고 출력해봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 불린형 (Boolean Type)\n",
    "\n",
    "파이썬에는 `True`와 `False`로 이뤄진 `bool` 타입이 있습니다.\n",
    "\n",
    "비교/논리 연산을 수행 등에서 활용됩니다.\n",
    "\n",
    "다음은 `False`로 변환됩니다.\n",
    "```\n",
    "0, 0.0, (), [], {}, '', None\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# print와 type을 이용하여 True와 False의 타입을 출력해 봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- bool() 함수\n",
    "    - 특정 데이터가 True인지 False인지 검증합니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 0, '', 1, [], -1, [1, 2, 3] 을 bool 함수를 이용하여 타입을 확인해 봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 0\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ''\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 1\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# []\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# -1\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# [1, 2, 3]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 비교 연산자 (Comparison Operator)\n",
    "\n",
    "우리가 수학에서 배운 연산자와 동일하게 값을 비교할 수 있습니다.\n",
    "\n",
    "|연산자|내용|\n",
    "|----|---|\n",
    "|`<`|미만|\n",
    "|`<=`|이하|\n",
    "|`>`|초과|\n",
    "|`>=`|이상|\n",
    "|`==`|같음|\n",
    "|`!=`|같지않음|\n",
    "|`is`|객체 아이덴티티|\n",
    "|`is not`|객체 아이덴티티가 아닌경우|\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 숫자의 대소관계를 비교해봅시다.\n",
    "# 아무 정수 2개를 비교해봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 다른 숫자인지 확인해봅시다.\n",
    "# 3의 정수형과 실수형이 같은지 비교해봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 같은 숫자인지 확인해봅시다.\n",
    "# 같은 숫자를 != 를 확인하여 비교해봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 문자열도 같은지 확인해봅시다.\n",
    "# 대문자 HI와 소문자 hi가 같은지 확인해 봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 특정 변수가 비어있는지 확인하기 위해서는\n",
    "# x == None이 아닌 x is None을 쓰는 것을 권장합니다.\n",
    "# 상세한 내용은 OOP 챕터에서 확인해 봅시다.\n",
    "x = 3\n",
    "x is None"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 논리 연산자\n",
    "\n",
    "|연산자|내용|\n",
    "|---|---|\n",
    "|a and b|a와 b 모두 True시만 True|\n",
    "|a or b|a 와 b 모두 False시만 False|\n",
    "|not a|True -> False, False -> True|\n",
    "\n",
    "다른 언어에서 논리연산자로 주로 사용하는 `&` 과 `|`은 파이썬에서 비트 연산자입니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# and과 관련해서 모든 경우를 출력해봅시다.\n",
    "# True와 False를 이용하여 and 의 모든 경우의 수(4개)를 출력해봅시다. \n",
    "# (True and True), (True and False), ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# or과 관련해서 모든 경우를 출력해봅시다.\n",
    "# True와 False를 이용하여 or 의 모든 경우의 수(4개)를 출력해봅시다.\n",
    "# (True or True), (True or False), ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# not을 활용해봅시다.\n",
    "# print를 이용하여 True 와 0의 not 값을 각각 확인해봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 파이썬에서 and는 a가 거짓이면 a를 리턴하고, 참이면 b를 리턴합니다.\n",
    "* 파이썬에서 or은 a가 참이면 a를 리턴하고, 거짓이면 b를 리턴합니다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "논리연산자는 비교연산자와 함께 사용 가능합니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "num = 100\n",
    "num >= 100 and num % 3 == 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 단축평가\n",
    "* 첫 번째 값이 확실할 때, 두 번째 값은 확인 하지 않습니다.\n",
    "* 조건문에서 뒷 부분을 판단하지 않아도 되기 때문에 속도가 향상됩니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 문자열 'a'와 'b'의 and 값이 무엇인지 확인해봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 문자열 'a'와 'b'의 or 값이 무엇인지 확인해봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vowels = 'aeiou'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 'a' and 'b' 의 결과값이 vowels에 포함이 되었는지 확인해봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 'b' and 'a' 의 결과값이 vowels에 포함이 되었는지 확인해봅시다. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- `and` 는 둘 다 `True`일 경우만 `True`이기 때문에 첫 번째 값이 `True`라도 두번째 값을 확인해야 하기 때문에 `'b'`가 반환됩니다.\n",
    "- `or` 는 하나만 `True`라도 `True`이기 때문에 `True`를 만나면 해당 값을 바로 반환합니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# and의 단축평가(short-circuit evaluation)에 대해서 알아봅시다.\n",
    "# (3 and 5) , (3 and 0), (0 and 3), (0 and 0) 의 결과를 print로 출력해봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(3 and 5)\n",
    "print(3 and 0)\n",
    "print(0 and 3)\n",
    "print(0 and 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# or의 단축평가(short-circuit evaluation)에 대해서 알아봅시다.\n",
    "# (3 or 5) , (3 or 0), (0 or 3), (0 or 0) 의 결과를 print로 출력해봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(5 or 3)\n",
    "print(3 or 0)\n",
    "print(0 or 3)\n",
    "print(0 or 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 컨테이너(Container)\n",
    "\n",
    "여러 개의 값을 저장할 수 있는 것(객체)을 의미하며, `서로 다른 자료형`을 저장 할 수 있습니다.\n",
    "\n",
    "### 컨테이너 분류\n",
    "- 시퀀스(Sequence)형 : 순서가 있는(ordered) 데이터\n",
    "- 비 시퀀스(Non-sequence)형 : 순서가 없는(unordered) 데이터\n",
    "\n",
    "<img width=\"712\" alt=\"container\" src=\"https://user-images.githubusercontent.com/45934087/148164052-3b12d3a2-a95e-4d4d-ae25-86ca1ba9657b.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 시퀀스(sequence)형 컨테이너\n",
    "\n",
    "`시퀀스`는 데이터가 순서대로 나열된(ordered) 형식을 나타냅니다. \n",
    "\n",
    "* **주의! 순서대로 나열된 것이 `정렬되었다(sorted)`라는 뜻은 아닙니다.**\n",
    "\n",
    "### 특징\n",
    "1. 순서가 있습니다.\n",
    "\n",
    "2. **특정 위치의 데이터를 가리킬 수 있습니다.**\n",
    "\n",
    "### 종류\n",
    "파이썬에서 기본적인 시퀀스 타입은 다음과 같습니다.\n",
    "\n",
    "* 리스트(list)\n",
    "\n",
    "* 튜플(tuple)\n",
    "\n",
    "* 레인지(range)\n",
    "\n",
    "* *문자형(string)*\n",
    "\n",
    "* *바이너리(binary)* : 다루지 않습니다.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "### 리스트 (List)\n",
    "\n",
    "<center><img src=\"https://user-images.githubusercontent.com/18046097/61180421-fe90ae80-a650-11e9-8211-d06f87756d05.png\", alt=\"list figure\"/></center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**생성과 접근**\n",
    "```python\n",
    "[value1, value2, value3]\n",
    "```\n",
    "\n",
    "리스트는 대괄호`[]` 및 `list()` 를 통해 만들 수 있습니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 빈 list를 만들어봅시다.\n",
    "# 변수명 my_list인 list를 대괄호로 만들어봅시다.\n",
    "# 변수명 another_list인 list를 list()로 만들어 봅시다.\n",
    "# 두 변수의 타입을 출력해 봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 원소를 포함한 list를 만들어 봅시다.\n",
    "# 변수명이 location인 list에 ssafy 지역 5곳을 원소로 포함해 만들어 봅시다.\n",
    "# 변수 location을 출력해 봅시다.\n",
    "# location의 타입을 출력해 봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# location의 첫번째 값을 인덱스로 접근해 봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "순서가 있는 시퀀스로 인덱스를 통해 접근 가능합니다.\n",
    "- 값에 대한 접근은 `list[i]` 방식으로 접근합니다.\n",
    "\n",
    "![image](https://user-images.githubusercontent.com/45934087/148164331-f0ff4193-6b05-4d99-bbde-dd1eef13b0b1.png)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 변수 boxes에 문자열 'A', 'B', 리스트 ['apple', 'banana', 'cherry']를 할당합니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# boxes의 길이를 len 함수를 이용하여 출력해 봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# boxes의 3번째 요소를 인덱스로 접근하여 출력해 봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# boxes의 3번째 요소들 중, 마지막 요소를 negative index로 접근하여 출력해 봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# boxes의 마지막 요소들 중, 두번째 요소의 첫번째 문자열을 출력해 봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 튜플 (Tuple)\n",
    "\n",
    "**생성과 접근**\n",
    "```python\n",
    "(value1, value2)\n",
    "```\n",
    "\n",
    "튜플은 리스트와 유사하지만, `()`로 묶어서 표현합니다.\n",
    "\n",
    "- tuple은 수정 불가능(불변, immutable)합니다.\n",
    "\n",
    "- 직접 사용하기 보다는 파이썬 내부에서 다양한 용도로 활용되고 있습니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# tuple을 만들어봅시다.\n",
    "# 변수명이 my_tuple인 tuple을 만들어 봅시다. 단, 무작위 정수 2개를 포함하여 만듭니다.\n",
    "# my_tuple의 타입을 출력해 봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_tuple = (1, 2)\n",
    "print(type(my_tuple))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 아래와 같은 방식으로도 만들 수 있습니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "another_tuple = 1, 2\n",
    "print(another_tuple)\n",
    "print(type(another_tuple))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**튜플 생성 주의 사항**\n",
    "- 단일 항목의 경우"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 하나의 항목으로 구성된 튜플은 생성 시 값 뒤에 쉼표를 붙여야 합니다.\n",
    "# 아래 코드를 실행하여 변수 a의 타입을 확인해 봅시다.\n",
    "a = 1,\n",
    "print(a)\n",
    "print(type(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 변수명이 single_tuple인 하나의 요소(값)로 구성된 tuple을 만들어 봅시다. (길이가 1)\n",
    "# 하나의 요소(값)로 구성된 tuple은 값 뒤에 쉼표를 붙여서 만듭니다.\n",
    "# single_tuple의 타입을 출력해 봅시다.\n",
    "# single_tuple의 길이를 출력해 봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "single_tuple = ('hello',)\n",
    "print(type(single_tuple))\n",
    "print(len(single_tuple))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 길이가 1인 tuple을 만들 때 쉼표가 없는 경우 어떻게 되는지 확인 해봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tuple_or_not = ('hello')\n",
    "print(type(tuple_or_not))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 복수 항목의 경우"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 마지막 항목에 붙은 쉼표는 생략 할 수 있습니다.\n",
    "# 아래 코드를 실행하여 변수 b와 c의 타입을 확인해 봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b = 1, 2, 3\n",
    "print(b)\n",
    "print(type(b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "c = 4, 5, 6,\n",
    "print(c)\n",
    "print(type(c))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**튜플 대입**\n",
    "- 우변의 값을 좌변의 변수에 한번에 할당하는 과정을 의미합니다.\n",
    "- 튜플은 일반적으로 파이썬 내부에서 활용됩니다.\n",
    "    - 추후 함수 파트에서 복수의 값을 반환하는 경우에도 확인할 수 있습니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 파이썬 내부에서는 다음과 같이 활용됩니다. (변수 및 자료형 예제에서 사용된 코드입니다.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x, y = 1, 2\n",
    "print(x)\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실제로는 tuple로 처리됩니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x, y = (1, 2)\n",
    "print(x)\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 변수의 값을 swap하는 코드 역시 tuple을 활용하고 있습니다. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "x, y = y, x\n",
    "print(x)\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 변수명이 empty인 빈 tuple을 만들어 봅시다.\n",
    "# 빈 tuple은 빈 괄호 쌍으로 만들어집니다.\n",
    "# empty의 타입을 출력해 봅시다.\n",
    "# empty의 길이를 출력해 봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "empty = ()\n",
    "print(type(empty))\n",
    "print(len(empty))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 레인지 (range())\n",
    "\n",
    "`range` 는 정수의 시퀀스를 나타내기 위해 사용됩니다.\n",
    "\n",
    "기본형 : `range(n)` \n",
    "\n",
    "\n",
    "> 0부터 n-1까지 값을 가짐\n",
    "\n",
    "\n",
    "범위 지정 : `range(n, m)` \n",
    "\n",
    "> n부터 m-1까지 값을 가짐\n",
    "\n",
    "범위 및 스텝 지정 : `range(n, m, s)`\n",
    "\n",
    "> n부터 m-1까지 +s만큼 증가한다"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# range를 만들어봅시다.\n",
    "# 0부터 2까지 값을 가지는 range를 만들고 타입을 출력해 봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 0부터 9까지 값을 가지는 range를 만들고 list로 형 변환을 해 봅시다.\n",
    "# 작성한 range를 list()로 감싸 형 변환 할 수 있습니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 4부터 8까지의 숫자를 담은 range를 만들고 list로 형 변환을 해 봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# range(start, end, [step, ])을 활용합니다.\n",
    "# 0부터 -9까지 담긴 range를 만들고 list로 형 변환을 해 봅시다.\n",
    "# 출력 결과는 다음과 같습니다.\n",
    "# [0, -1, -2, -3, -4, -5, -6, -7, -8, -9]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 인덱싱/슬라이싱 (Indexing/Slicing)\n",
    "`[]`를 통한 값을 접근하고, `[:]`을 통해 슬라이싱할 수 있습니다. (data structure 챕터에서 자세하게 학습합니다.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 인덱싱\n",
    "시퀀스의 특정 인덱스 값에 접근 할 수 있습니다.\n",
    "- 해당 인덱스가 없는 경우 IndexError가 발생합니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 리스트를 인덱싱을 통해 값에 접근해봅시다.\n",
    "# 리스트 [1, 2, 3]의 세번째 값을 인덱싱으로 확인해봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 튜플을 인덱싱을 통해 값에 접근해봅시다.\n",
    "# 튜플 (1, 2, 3)의 첫번째 값을 인덱싱으로 확인해봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# range를 인덱싱을 통해 값에 접근해봅시다.\n",
    "# range(3)의 세번째 값을 인덱싱으로 확인해봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 문자열을 인덱싱을 통해 값에 접근해봅시다.\n",
    "# 문자열 'abc'의 첫번째 값을 인덱싱으로 확인해봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 찾고자 하는 인덱스가 존재하지 않을때 오류가 발생합니다.\n",
    "# 문자열 apple의 100번째 값을 인덱싱으로 확인하고자 할 때 발생하는 오류를 확인해봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 슬라이싱\n",
    "- Sequence[start:end[:step]]\n",
    "\n",
    "시퀀스를 특정 단위로 슬라이싱 할 수 있습니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 아래 코드들을 실행한 결과를 확인하여 슬라이싱의 작동 원리를 파악해봅시다.\n",
    "print([1, 2, 3, 4][1:4])\n",
    "print((1, 2, 3)[:2])\n",
    "print(range(10)[5:8])\n",
    "print('abcd'[2:4])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "시퀀스를 `k` 간격으로 슬라이싱 할 수 있습니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 아래 코드들을 실행한 결과를 확인하여 슬라이싱의 작동 원리를 파악해봅시다.\n",
    "# 문자열, 튜플, 레인지에서 모두 동일하게 동작합니다.\n",
    "print([1, 2, 3, 4][0:4:2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 아래의 코드를 실행하여 결과를 확인해 봅시다.\n",
    "s = 'abcdefghi'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(s[:3])\n",
    "print(s[5:])\n",
    "print(s[::])\n",
    "print(s[::-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 비시퀀스형 형태"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 딕셔너리 (dictionary)\n",
    "\n",
    "`dictionary`는 `key`와 `value`가 쌍으로 이뤄져있습니다.\n",
    "\n",
    "\n",
    "<center><img src=\"https://user-images.githubusercontent.com/18046097/61180427-1405d880-a651-11e9-94e1-1cc5c2a2ff34.png\"></center> "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**생성과 접근**\n",
    "\n",
    "```python\n",
    "{Key1:Value1, Key2:Value2, Key3:Value3, ...}\n",
    "```\n",
    "\n",
    "* `{}`를 통해 만들며, `dict()`로 만들 수 있습니다.\n",
    "* 순서를 보장하지 않습니다.\n",
    "* `key`는 **변경 불가능(immutable)한 데이터**만 가능합니다. (immutable : string, integer, float, boolean, tuple, range)\n",
    "* `value`는 `list`, `dictionary`를 포함한 모든 것이 가능합니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 비어있는 dictionary를 두가지 방법으로 만들어봅시다.\n",
    "# {}와 dict()로 만들 수 있습니다.\n",
    "# 두 변수의 타입을 출력해 봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# dictionary에 중복된 key는 존재할 수 없습니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dict_a = {1: 1, 2: 2, 3: 3, 1: 4}\n",
    "print(dict_a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 지역번호가 담긴 전화번호부를 만들어봅시다.\n",
    "# 변수 phone_book에 key를 지역명, value를 지역번호로 가지는 원소를 작성합니다.\n",
    "# 예) 서울 - 02"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 위에서 작성한 phone_book이 가지고 있는 key 목록을 확인 해 봅시다.\n",
    "# dictionary의 .keys() 메소드를 활용하여 key를 확인 해볼 수 있습니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 위에서 작성한 phone_book이 가지고 있는 value 목록을 확인 해 봅시다.\n",
    "# 딕셔너리의 .values() 메소드를 활용하여 value를 확인 해볼 수 있습니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 위에서 작성한 phone_book이 가지고 있는 key와 value 목록을 확인 해 봅시다.\n",
    "# 딕셔너리의 .items() 메소드를 활용하여 key, value를 확인 해볼 수 있습니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 형변환(Type conversion, Typecasting)\n",
    "\n",
    "파이썬에서 데이터타입은 서로 변환할 수 있습니다.\n",
    "\n",
    "- 암시적 형변환\n",
    "- 명시적 형변환\n",
    "\n",
    "## 암시적 형변환(Implicit Typecasting)\n",
    "\n",
    "사용자가 의도하지 않았지만, 파이썬 내부적으로 자동으로 형변환 하는 경우입니다. 아래의 상황에서만 가능합니다.\n",
    "\n",
    "- bool\n",
    "- Numeric Type (int, float, complex)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# boolean과 integer는 더할 수 있을까요?\n",
    "# True와 임의의 정수를 더해봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# int, float, complex를 각각 변수에 대입해봅시다.\n",
    "# 변수 int_number 에 정수를 할당해봅시다.\n",
    "# 변수 float_numbe 에 실수를 할당해봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# int와 float를 더해봅시다. 그리고 값을 출력해봅시다.\n",
    "# 그 결과의 type은 무엇일까요?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# int와 complex를 더해봅시다. 그리고 값을 출력해봅시다.\n",
    "# 그 결과의 type은 무엇일까요?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 명시적 형변환(Explicit Typecasting)\n",
    "\n",
    "위의 상황을 제외하고는 모두 명시적으로 형변환을 해주어야합니다.\n",
    "\n",
    "- string -> intger : 형식에 맞는 숫자만 가능\n",
    "- integer -> string : 모두 가능\n",
    "\n",
    "암시적 형변환이 되는 모든 경우도 명시적으로 형변환이 가능합니다.\n",
    "\n",
    "- `int()` : string, float를 int로 변환\n",
    "- `float()` : string, int를 float로 변환\n",
    "- `str()` : int, float, list, tuple, dictionary를 문자열로 변환"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# integer와 string 사이의 관계는 명시적으로 형변환을 해줘야만 합니다.\n",
    "# 정수와 문자열을 더해보고 오류를 확인해봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정수를 문자열로 형변환하고 문자열과 더해봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 변수 a에 string 3을 할당하고 integer로 변환해봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 변수 a에 string 3.5를 할당하고 float로 변환해봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# string은 글자가 숫자일때만 형변환이 가능합니다.\n",
    "# 변수 a에 문자열 'hi'를 할당하고 integer로 변환해봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# string 3.5를 int로 변환할 수는 없습니다.\n",
    "# 변수 a에 string 3.5를 저장하고 integer로 변환하고 오류를 확인해봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# float 3.5는 int로 변환이 가능합니다.\n",
    "# 변수 a에 실수 3.5를 저장하고 integer로 변환해봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 컨테이너형 형변환\n",
    "\n",
    "파이썬에서 컨테이너는 서로 변환할 수 있습니다.\n",
    "\n",
    "<img width=\"708\" alt=\"typecasting\" src=\"https://user-images.githubusercontent.com/18046097/61180466-a6a67780-a651-11e9-8c0a-adb9e1ee04de.png\">\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 하나의 결과를 확인 한 후, 주석 `#` 을 활용하여 이전의 코드를 비활성화 합니다.\n",
    "# 형변환 후의 결과를 확인 합니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# list를 형변환 해봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l = [1, 2, 3, 4]\n",
    "str(l)\n",
    "tuple(l)\n",
    "set(l)\n",
    "# range(l)\n",
    "# dict(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# tuple을 형변환 해봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t = (1, 2, 3, 4)\n",
    "str(t)\n",
    "list(t)\n",
    "set(t)\n",
    "# range(t)\n",
    "# dict(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# range를 형변환 해봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "r = range(1, 5)\n",
    "str(r)\n",
    "list(r)\n",
    "set(r)\n",
    "tuple(r)\n",
    "# dict(r)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# set을 형변환 해봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = {1, 2, 3, 4}\n",
    "str(s)\n",
    "list(s)\n",
    "tuple(s)\n",
    "# range(s)\n",
    "# dict(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# dictionary를 형변환 해봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d = {'name': 'ssafy', 'year': 2020}\n",
    "str(d)\n",
    "list(d)\n",
    "tuple(d)\n",
    "set(d)\n",
    "# range(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 정리"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 프로그램 구성 단위"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 식별자(identifier)\n",
    "- 변수, 함수, 클래스 등 프로그램이 실행되는 동안 다양한 값을 가질수 있는 이름을 의미합니다.\n",
    "- 예약어는 사용이 불가능합니다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 리터럴(literal)\n",
    "- 읽혀지는 대로 쓰여있는 값 그 자체를 의미합니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# name은 식별자 == 변수\n",
    "# '김싸피'은 리터럴\n",
    "name = '김싸피'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 연산자 우선순위\n",
    "\n",
    "0. `()`을 통한 grouping\n",
    "\n",
    "1. Slicing\n",
    "\n",
    "2. Indexing\n",
    "\n",
    "3. 제곱연산자\n",
    "    `**`\n",
    "\n",
    "4. 단항연산자 \n",
    "    `+`, `-` (음수/양수 부호)\n",
    "\n",
    "5. 산술연산자\n",
    "    `*`, `/`, `%`\n",
    "    \n",
    "6. 산술연산자\n",
    "    `+`, `-`\n",
    " \n",
    "7. 비교연산자, `in`, `is`\n",
    "\n",
    "8. `not`\n",
    "\n",
    "9. `and` \n",
    "\n",
    "10. `or`\n",
    "\n",
    "[파이썬 문서](https://docs.python.org/ko/3/reference/expressions.html#operator-precedence)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 우선순위를 확인해봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# -3 ** 6의 값을 확인해봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# (-3) ** 6의 값을 확인해봅시다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 변수(Variable)와 자료형(Data Type)\n",
    "\n",
    "<center><img width=800 height=400 src=\"https://user-images.githubusercontent.com/9452521/87640197-55a7f280-c781-11ea-9cff-19c022ce704a.png\", alt=\"variable\"/></center>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 컨테이너(Container)\n",
    "<center><img src=\"https://user-images.githubusercontent.com/18046097/61180439-44e60d80-a651-11e9-9adc-e60fa57c2165.png\", alt=\"container\"/></center>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 표현식 (Expression)\n",
    "- 새로운 데이터 값을 생성하거나 계산하는 코드 조각을 의미합니다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 문장 (Statement)\n",
    "- 특정한 작업을 수행하는 코드 전체를 의미합니다.\n",
    "- 파이썬이 실행 가능한 최소한의 코드 단위를 말합니다.\n",
    "- 표현식은 값을 생성하는 일부분이고, 문장은 특정 작업을 수행하는 코드 전체 입니다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 문장과 표현식의 관계\n",
    "\n",
    "<center><img width=\"600\" height=\"300\" src=\"https://user-images.githubusercontent.com/9452521/87619771-f41f5e00-c757-11ea-9e4b-1f76e4ca0981.png\", alt=\"variable\"/></center>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 하나의 값(value)도 문장이 될 수 있습니다.\n",
    "'ssafy'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 표현식(expression)도 문장이 될 수 있습니다.\n",
    "5 * 21 - 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 실행 가능(executable)해야 하기 때문에 아래의 코드는 문장이 될 수 없습니다.\n",
    "name = '"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "hide_input": false,
  "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.9.9"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Python 기초",
   "toc_cell": false,
   "toc_position": {
    "height": "757px",
    "left": "53px",
    "top": "111.125px",
    "width": "233.4px"
   },
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}