CH01-04. 기본 문법 및 데이터 타입 소개2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# [ 1-4. 기본 문법 및 데이터 타입 소개2 ]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **4. 리스트(List)**\n",
    "리스트(List)는 여러 값을 순서대로 저장하는 데 사용되는 자료형입니다. 리스트는 다양한 데이터 타입의 값들을 포함할 수 있으며, 변경 가능(mutable)하여 리스트 내의 값을 추가, 삭제, 또는 변경할 수 있습니다.\n",
    "### 4-1. 리스트 기본 사용방법\n",
    "리스트는 대괄호 \"[]\" 안에 값들을 쉼표로 구분하여 나열함으로써 생성할 수 있습니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list = [1, 2, 3]\n",
    "names = [\"Alice\", \"Bob\", \"Charlie\"]\n",
    "mixed = [1, \"Alice\", True, 2.34]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "리스트의 값에 접근하기 위해서는 인덱스를 사용합니다. 인덱스는 0부터 시작합니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Alice\n"
     ]
    }
   ],
   "source": [
    "print(names[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.34\n"
     ]
    }
   ],
   "source": [
    "print(mixed[3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Charlie\n"
     ]
    }
   ],
   "source": [
    "print(names[-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "append() 메서드 : 리스트 맨 뒤에 값 추가"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Alice', 'Bob', 'Charlie', 'Diana']\n"
     ]
    }
   ],
   "source": [
    "names.append(\"Diana\")\n",
    "print(names)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "insert() 메서드 : 특정 위치에 값 삽입"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Alice', 'Eve', 'Bob', 'Charlie', 'Diana']\n"
     ]
    }
   ],
   "source": [
    "names.insert(1, \"Eve\")\n",
    "print(names)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "extend() 메서드 : 튜플이나 리스트 등의 여러 값을 한번에 삽입"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Alice', 'Eve', 'Bob', 'Charlie', 'Diana', 'Alice', 'Bob']\n"
     ]
    }
   ],
   "source": [
    "names.extend([\"Alice\", \"Bob\"])\n",
    "print(names)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "index(찾고자 하는 값 [, 시작점] [, 종결점]) 메서드 : 값의 위치 확인(처음 찾은 결과만 반환)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "names.index(\"Alice\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "names.index(\"Alice\", 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "names.index(\"Bob\", 3, 7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "count() 메서드 : 해당 값의 개수 반환"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "names.count(\"Alice\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "pop([위치]]) 메서드 : 인자를 생략하면 가장 뒤의 값을 추출하며, 위치 인자를 입력하면 해당 위치의 값을 추출합니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Alice', 'Eve', 'Bob', 'Charlie', 'Diana', 'Alice', 'Bob']\n"
     ]
    }
   ],
   "source": [
    "print(names)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Alice', 'Eve', 'Bob', 'Charlie', 'Diana', 'Alice']\n",
      "Bob\n"
     ]
    }
   ],
   "source": [
    "poppedval = names.pop()\n",
    "print(names)\n",
    "print(poppedval)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Alice', 'Eve', 'Bob', 'Diana', 'Alice']\n",
      "Charlie\n"
     ]
    }
   ],
   "source": [
    "poppedval = names.pop(3)\n",
    "print(names)\n",
    "print(poppedval)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "sort() 메서드 : 리스트 값들을 정렬"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Alice', 'Alice', 'Bob', 'Diana', 'Eve']\n"
     ]
    }
   ],
   "source": [
    "names.sort()\n",
    "print(names)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Eve', 'Diana', 'Bob', 'Alice', 'Alice']\n"
     ]
    }
   ],
   "source": [
    "# reverse 인자 설정을 통해 역순으로 정렬할 수 있음.\n",
    "names.sort(reverse=True)\n",
    "print(names)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### [참고] 메서드(method)와 속성(attribute)\n",
    "* 메서드(method)는 객체에 속한 함수로, 객체의 데이터를 조작하거나 특정 작업을 수행하는 데 사용됩니다.\n",
    "\n",
    "* 속성은 객체에 속한 변수로, 객체의 상태를 나타내는 데이터입니다.\n",
    "\n",
    "=> 메서드는 객체의 동작을 정의하며, '객체.메서드()' 형식으로 호출됩니다. 속성에는 직접 접근할 수 있으며, '객체.속성' 형식으로 사용됩니다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4-2. 리스트 슬라이싱\n",
    "리스트 슬라이싱은 파이썬에서 리스트의 일부분을 선택하여 새로운 리스트를 생성하는 기능입니다.\n",
    "슬라이싱은 \"리스트[시작 인덱스 : 끝 인덱스 : 간격]\" 형태로 사용됩니다.\n",
    "\n",
    "* 시작 인덱스 : 슬라이싱할 범위의 시작점입니다(포함). 생략하면 리스트의 시작부터 슬라이싱합니다.\n",
    "\n",
    "* 끝 인덱스 : 슬라이싱할 범위의 끝점입니다(미포함). 생략하면 리스트의 끝까지 슬라이싱합니다.\n",
    "\n",
    "* 간격 : 선택적으로, 슬라이싱할 요소들 사이의 간격을 지정합니다. 생략하면 기본값은 \"1\"입니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
      "[2, 3, 4]\n",
      "[0, 1, 2, 3]\n",
      "[3, 4, 5, 6, 7, 8, 9]\n",
      "[0, 2, 4, 6, 8]\n",
      "[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]\n"
     ]
    }
   ],
   "source": [
    "my_list = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
    "\n",
    "# 전체 리스트 슬라이싱\n",
    "print(my_list[:])  # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
    "\n",
    "# 시작 인덱스 2부터 끝 인덱스 5까지 슬라이싱 (5는 포함되지 않음)\n",
    "print(my_list[2:5])  # [2, 3, 4]\n",
    "\n",
    "# 리스트의 시작부터 끝 인덱스 3까지 슬라이싱\n",
    "print(my_list[:4])  # [0, 1, 2, 3]\n",
    "\n",
    "# 시작 인덱스 3부터 리스트 끝까지 슬라이싱\n",
    "print(my_list[3:])  # [3, 4, 5, 6, 7, 8, 9]\n",
    "\n",
    "# 간격을 2로 설정하여 슬라이싱\n",
    "print(my_list[::2])  # [0, 2, 4, 6, 8]\n",
    "\n",
    "# 리스트를 거꾸로 슬라이싱\n",
    "print(my_list[::-1])  # [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4-3. 리스트 컴프리헨션(List Comprehension)\n",
    "리스트 컴프리헨션(List Comprehension)은 파이썬에서 리스트를 생성하는 간결하고 효율적인 방법입니다. 이 방식은 기존 리스트를 사용해 새로운 리스트를 만들 때, 반복문과 조건문을 한 줄의 코드로 표현할 수 있게 해줍니다. 리스트 컴프리헨션은 코드의 가독성을 높이고, 길이가 긴 반복문 코드를 단축시켜 줍니다.\n",
    "\n",
    "#### [기본 내용]\n",
    "\n",
    "리스트 컴프리헨션의 기본 구조는 다음과 같습니다.\n",
    "\n",
    "**[표현식 for 항목 in 반복가능객체 if 조건문]**\n",
    "\n",
    "* 표현식 : 새로운 리스트의 각 요소에 대한 연산이나 처리를 정의합니다.\n",
    "\n",
    "* for 항목 in 반복가능객체 : 기존 리스트(또는 반복 가능한 다른 객체)를 순회하는 반복문입니다.\n",
    "\n",
    "* if조건문 : (선택적)조건에 맞는 요소에 대해서만 표현식을 적용합니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]\n"
     ]
    }
   ],
   "source": [
    "# 0부터 9까지의 숫자 중에 대해서 제곱을 구하여 새로운 리스트 생성\n",
    "squares = [x**2 for x in range(10)]\n",
    "print(squares)  # 출력: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 4, 16, 36, 64]\n"
     ]
    }
   ],
   "source": [
    "# 0부터 9까지의 숫자 중에서 짝수의 제곱을 구하여 새로운 리스트 생성\n",
    "squares = [x**2 for x in range(10) if x % 2 == 0]\n",
    "print(squares)  # 출력: [0, 4, 16, 36, 64]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]\n"
     ]
    }
   ],
   "source": [
    "# 두 리스트의 모든 조합을 포함하는 새로운 리스트 생성\n",
    "pairs = [(x, y) for x in [1, 2, 3] for y in [3, 1, 4] if x != y]\n",
    "print(pairs)  # 출력: [(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### [장점]\n",
    "* 간결성 : 여러줄의 코드를 한 줄로 줄일 수 있어 코드가 더 간결해 집니다.\n",
    "\n",
    "* 표현력 : 리스트를 생성하는 로직을 명확하게 표현할 수 있습니다.\n",
    "\n",
    "* 성능 : 일반적인 for 반복문에 비해 리스트 컴프리헨션의 실행속도가 더 빠를 수 있습니다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### [for문과의 비교]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]\n"
     ]
    }
   ],
   "source": [
    "# for문을 사용하여 제곱값 구하기\n",
    "squares = []  # 빈 리스트를 생성\n",
    "for x in range(10):  # 0부터 9까지 숫자에 대해서 반복\n",
    "    squares.append(x**2)  # 현재 숫자의 제곱을 squares 리스트에 추가\n",
    "print(squares)  # 출력: [0, 4, 16, 36, 64, 81]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "for문을 사용하면 리스트 컴프리헨션에 비해 코드가 조금 더 길어지지만, 코드의 작동 방식을 좀 더 명확하게 이해할 수 있습니다. 또한 복잡한 로직을 처리할 때는 for문을 사용하는 것이 더 적합할 수 있습니다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### [참고] range함수\n",
    "range() 함수는 파이썬에서 숫자 시퀀스를 생성하는데 사용됩니다.\n",
    "\n",
    "* range(종료값) : 0부터 시작하여 종료값 바로 앞까지의 숫자를 포함하는 시퀀스를 생성합니다.(종료값 미포함)\n",
    "\n",
    "* range(시작값, 종료값) : 시작값에서 시작하여 종료값 바로 앞까지의 숫자를 포함하는 시퀀스를 생성합니다.(종료값 미포함)\n",
    "\n",
    "* range(시작값, 종료값, 증가값) : 시작값에서 시작하여 증가값만큼 숫자를 증가시키면서, 종료값 바로 앞까지의 숫자를 포함하는 시퀀스를 생성합니다. 증가값으로 음수를 지정하면 숫자가 감소합니다.\n",
    "\n",
    "=> 주의사항 : range() 함수는 실제로 리스트를 생성하지 않습니다. 대신, 지정된 범위에 따라 숫자를 순차적으로 생성하는 range 객체를 반환합니다. 따라서 메모리를 효율적으로 사용할 수 있습니다. 실제 리스트가 필요한 경우 list()함수를 사용하여 결과를 리스트로 변환할 수 있습니다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **5. 튜플(Tuple)**\n",
    "튜플(Tuple)은 파이썬의 기본 자료형 중 하나로, 여러 값을 순서대로 저장하는데 사용되는 자료형 입니다. 리스트와 유사하게 데이터를 순서대로 저장하지만, 튜플은 한 번 생성되면 그 안에 저장된 데이터를 변경할 수 없습니다. 이러한 특성 때문에 튜플은 프로그램 실행 도중 값이 변경되지 않아야 하는 데이터를 저장하는 데 적합합니다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5-1. 튜플 특징\n",
    "* 불변성(Immutability) : 튜플에 저장된 데이터는 변경할 수 없습니다. 이는 튜플의 값을 추가, 삭제, 변경할 수 없다는 의미입니다. 이는 데이터가 의도치 않게 변경되는 것을 방지하고 프로그램의 안정성을 높이는 데 도움을 줍니다.\n",
    "\n",
    "* 순서가 있음(Ordered) : 튜플의 값들은 순서를 가지고 있어, 인덱싱이나 슬라이싱을 통해 접근할 수 있습니다.\n",
    "\n",
    "* 중복 허용 : 튜플 내에서 같은 값을 여러개 가질 수 있습니다.\n",
    "\n",
    "* 읽기 전용 : 읽기 전용으로 제공되는 메서드는 count(), index() 정도뿐으로 적습니다. 하지만 기능이 적은만큼 리스트에 비해 속도가 빠르고 적은 메모리를 사용합니다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5-2. 튜플의 사용"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_tuple = (1, 2, 3)\n",
    "single_element_tuple = (42,) # 값이 하나만 있는 튜플으르 생성하는 경우 뒤에 쉼표를 붙여야 함"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3) (42,)\n"
     ]
    }
   ],
   "source": [
    "print(my_tuple, single_element_tuple)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5-3. 파이썬 내부에서 튜플 사용\n",
    "파이썬 내부에서는 알게 모르게 튜플이 사용되는 경우가 많습니다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 5-3-1. 함수의 반환 값\n",
    "파이썬에서 함수는 여러 값을 튜플로 묶어 반환할 수 있습니다. 이는 하나의 함수 호출로 여러 값을 반환받고 싶을 때 사용합니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 5\n"
     ]
    }
   ],
   "source": [
    "def min_max(values):\n",
    "    return min(values), max(values)\n",
    "minimum, maximum = min_max([1, 2, 3, 4, 5])\n",
    "print(minimum, maximum)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 5-3-2. 패킹 및 언패킹\n",
    "여러 변수에 동시에 값을 할당하는 과정에서 튜플이 내부적으로 사용됩니다. 이를 튜플 패킹 및 언패킹이라고 합니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "value a : 1\n",
      "value b : 2\n"
     ]
    }
   ],
   "source": [
    "a, b = 1, 2  # 튜플 패킹 및 언패킹\n",
    "print(f\"value a : {a}\")\n",
    "print(f\"value b : {b}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 5-3-3. for 루프와 함께 사용\n",
    "'enumerate' 함수나 'dict.items()' 메서드와 같이 튜플을 반환하는 함수와 함께 for 루프에서 튜플 언패킹을 사용할 수 있습니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 a\n",
      "1 b\n",
      "2 c\n"
     ]
    }
   ],
   "source": [
    "for index, value in enumerate(['a', 'b', 'c']):\n",
    "    print(index, value)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6. 세트(Set)\n",
    "세트(Set)는 순서가 없고 중복된 요소를 갖지 않는 값의 나열입니다. 세트는 수학의 집합 개념을 컴퓨터 과학에 도입한 것으로, 고유한 요소의 모음으로 생각할 수 있습니다. 세트는 중괄호 \"{}\" 또는 \"set()\" 함수를 사용하여 생성할 수 있습니다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6-1. 세트 특징\n",
    "* 중복 없음 : 세트에는 같은 값이 두 번 포함될 수 없습니다. 이 특성은 데이터의 중복을 제거하는 데 유용합니다.\n",
    "\n",
    "* 순서 없음 : 세트는 요소 간 순서를 유지하지 않습니다. 따라서, 인덱스로 개별 요소에 접근할 수 없습니다.\n",
    "\n",
    "* 가변성 : 세트는 요소를 추가하거나 제거할 수 있으며, 이를 통해 동적으로 세트의 내용을 변경할 수 있습니다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6-2. 세트의 사용"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3, 4, 5}\n",
      "{1, 2, 3, 4, 5}\n"
     ]
    }
   ],
   "source": [
    "# 중괄호를 사용한 세트 생성\n",
    "my_set = {1, 2, 3, 4, 5}\n",
    "\n",
    "# set() 함수를 사용한 세트 생성\n",
    "second_set = set([1, 2, 3, 4, 5])\n",
    "\n",
    "print(my_set)\n",
    "print(second_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3, 4, 5, 6}\n",
      "{3, 4}\n",
      "{1, 2}\n",
      "{1, 2, 5, 6}\n"
     ]
    }
   ],
   "source": [
    "a = {1, 2, 3, 4}\n",
    "b = {3, 4, 5, 6}\n",
    "\n",
    "# 합집합\n",
    "print(a | b)  # {1, 2, 3, 4, 5, 6}\n",
    "\n",
    "# 교집합\n",
    "print(a & b)  # {3, 4}\n",
    "\n",
    "# 차집합\n",
    "print(a - b)  # {1, 2}\n",
    "\n",
    "# 대칭 차집합 (합집합 - 교집합)\n",
    "print(a ^ b)  # {1, 2, 5, 6}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6-3. 세트의 메서드"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* add() 메서드 : 세트에 값을 추가합니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'orange', 'banana', 'apple', 'cherry'}\n"
     ]
    }
   ],
   "source": [
    "fruits = {\"apple\", \"banana\", \"cherry\"}\n",
    "fruits.add(\"orange\")\n",
    "print(fruits)  # {'cherry', 'banana', 'orange', 'apple'}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* remove() 메서드 : 세트에서 값을 제거합니다. 값이 세트에 없는 경우 'KeyError'를 발생시킵니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'orange', 'apple', 'cherry'}\n"
     ]
    }
   ],
   "source": [
    "fruits.remove(\"banana\")\n",
    "print(fruits)  # {'cherry', 'orange', 'apple'}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* discard() 메서드 : 세트에서 값을 제거합니다. 값이 세트에 없어도 에러를 발생시키지 않습니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'orange', 'apple', 'cherry'}\n"
     ]
    }
   ],
   "source": [
    "fruits.discard(\"banana\")\n",
    "print(fruits)  # {'cherry', 'orange', 'apple'}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* clear() 메서드 : 세트의 모든 요소를 제거합니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "set()\n"
     ]
    }
   ],
   "source": [
    "fruits.clear()\n",
    "print(fruits)  # set()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* pop() 메서드 : 세트에서 하나의 요소를 무작위로 제거하고 그 요소를 반환합니다. 세트가 비어있을 경우 'KeyError'가 발생합니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "banana\n",
      "{'apple', 'cherry'}\n"
     ]
    }
   ],
   "source": [
    "fruits = {\"apple\", \"banana\", \"cherry\"}\n",
    "removed_fruit = fruits.pop()\n",
    "print(removed_fruit)  # 'cherry', 'orange', 'apple' 중 하나\n",
    "print(fruits)  # 제거된 요소를 제외한 나머지"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* union() 메서드 : 두 세트의 합집합을 반환합니다.\n",
    "\n",
    "* update() 메서드 : 기존 세트를 두 세트의 합집합으로 갱신합니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3, 4, 5}\n",
      "{1, 2, 3, 4, 5}\n"
     ]
    }
   ],
   "source": [
    "a = {1, 2, 3}\n",
    "b = {3, 4, 5}\n",
    "c = a.union(b)\n",
    "print(c)  # {1, 2, 3, 4, 5}\n",
    "a.update(b)\n",
    "print(a)  # {1, 2, 3, 4, 5}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 7. 딕셔너리(Dictionary)\n",
    "딕셔너리(Dictionary), 또는 딕셔너리는 파이썬의 핵심 데이터 구조 중 하나로, 키(Key)와 값(Value)의 쌍으로 데이터를 저장합니다. 딕셔너리는 \"{}\"를 사용하여 생성하며, 각 키와 값은 \"Key: Value\" 형태로 표현됩니다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7-1. 딕셔너리의 특징\n",
    "* 변경 가능 : 딕셔너리는 가변 객체로, 저장된 데이터를 변경할 수 있습니다.\n",
    "\n",
    "* 순서 없음 : 딕셔너리는 기본적으로 순서에 의존하지 않는 데이터 구조입니다. (파이썬 3.7 이전까지는 요소의 순서를 보장하지 않았습니다. 파이썬 3.7 이후부터는 삽입 순서를 유지합니다.)\n",
    "\n",
    "* 키의 유일성 : 딕셔너리에서 각 키는 유일해야 하며, 한 키에 하나의 값만 매핑됩니다. 같은 키에 다른 값을 할당하면 이전 값이 덮어씌워집니다.\n",
    "\n",
    "* 다양한 데이터 타입 : 딕셔너리의 키로는 변경 불가능(immutable)한 데이터 타입만 사용할 수 있습니다(문자열, 숫자, 튜플 등). 값으로는 어떤 데이터 타입도 사용할 수 있습니다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7-2. 딕셔너리 사용 예시"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Alice\n",
      "name Alice\n",
      "email alice@example.com\n"
     ]
    }
   ],
   "source": [
    "# 딕셔너리 생성\n",
    "my_dict = {'name': 'Alice', 'age': 30, 'city': 'New York'}\n",
    "\n",
    "# 값 접근\n",
    "print(my_dict['name'])  # Alice\n",
    "\n",
    "# 값 추가 및 변경\n",
    "my_dict['email'] = 'alice@example.com'  # 새로운 키-값 쌍 추가\n",
    "my_dict['age'] = 31  # 기존 키에 대한 값 변경\n",
    "\n",
    "# 값 제거\n",
    "del my_dict['city']  # 키와 그 값을 삭제\n",
    "my_dict.pop('age')  # 'age' 키와 값을 삭제하고 값을 반환\n",
    "\n",
    "# 키 존재 확인\n",
    "'city' in my_dict  # False\n",
    "\n",
    "# 모든 키와 값 순회\n",
    "for key, value in my_dict.items():\n",
    "    print(key, value)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7-3. 딕셔너리의 메서드\n",
    "* keys() 메서드 : 딕셔너리의 모든 키를 반환합니다. 반환된 키 값들은 리스트와 비슷하지만, 리스트의 메서드를 사용할 수는 없습니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_keys(['name', 'age', 'city'])\n"
     ]
    }
   ],
   "source": [
    "person = {'name': 'Alice', 'age': 30, 'city': 'New York'}\n",
    "keys = person.keys()\n",
    "print(keys)  # dict_keys(['name', 'age', 'city'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* values() 메서드 : 딕셔너리의 모든 값을 반환합니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_values(['Alice', 30, 'New York'])\n"
     ]
    }
   ],
   "source": [
    "values = person.values()\n",
    "print(values)  # dict_values(['Alice', 30, 'New York'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* items() 메서드 : 딕셔너리의 모든 키-값 쌍을 튜플로 묶어 반환합니다. 이 메서드는 딕셔너리를 순회할 때 매우 유용합니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_items([('name', 'Alice'), ('age', 30), ('city', 'New York')])\n"
     ]
    }
   ],
   "source": [
    "items = person.items()\n",
    "print(items)  # dict_items([('name', 'Alice'), ('age', 30), ('city', 'New York')])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* get(key[, default]) 메서드 : 지정한 키에 대한 값을 반환합니다. 키가 딕셔너리에 없는 경우 'None'이나, 'default' 인자로 전달된 기본값을 반환합니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Not Available\n"
     ]
    }
   ],
   "source": [
    "email = person.get('email', 'Not Available')\n",
    "print(email)  # Not Available"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* pop(key[, default]) 메서드 : 지정한 키에 대한 값을 반환하고, 해당 키-값 쌍을 딕셔너리에서 제거합니다. 키가 없는 경우 'default'를 반환하며, 'default'가 제공되지 않고 키가 없는 경우 'KeyError'를 발생시킵니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "30\n",
      "{'name': 'Alice', 'city': 'New York'}\n"
     ]
    }
   ],
   "source": [
    "age = person.pop('age')\n",
    "print(age)  # 30\n",
    "print(person)  # {'name': 'Alice', 'city': 'New York'}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* update([other]) 메서드 : 다른 딕셔너리 'other'의 키-값 쌍으로 현재 딕셔너리를 갱신합니다. 'other'에 같은 키가 있으면 해당 값으로 덮어씁니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'name': 'Alice', 'city': 'New York', 'age': 31, 'email': 'alice@example.com'}\n"
     ]
    }
   ],
   "source": [
    "person.update({'age': 31, 'email': 'alice@example.com'})\n",
    "print(person)  # {'name': 'Alice', 'city': 'New York', 'age': 31, 'email': 'alice@example.com'}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 8. 부울(Bool)\n",
    "파이썬에서 'bool' 타입은 정수의 하위 유형으로, 논리적 값인 'True' 또는 'False'를 나타냅니다. 이 값들은 조건문과 반복문에서 표현식의 참 또는 거짓 값을 나타내는 데 사용되어, 논리 연산을 수행하는 데 쓰입니다.\n",
    "\n",
    "파이선에서 'bool'은 내장 타입이며, 모든 객체는 참 거짓 값을 가집니다. 'if'나 'while' 조건문 또는 논리 연산의 피연산자로 사용될 수 있습니다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 8-1. 'bool'에 대한 주요 내용\n",
    "* 'True'와 'False' : 'bool' 타입의 유일한 두 가지 값입니다.\n",
    "\n",
    "* 참 거짓 값 판단 : 파이썬은 값이 참인지 거짓인지를 자동으로 평가합니다. 예를 들어, '0', 'None', '[]', '{}', '\"\"'은 'False'로 간주되며, 0이 아닌 숫자, 비어 있지 않은 문자열, 리스트, 튜플, 세트, 딕셔너리는 'True'로 간주됩니다.\n",
    "\n",
    "* 정수에서 파생됨 : 'True'는 '1'과 동등하고, 'False'는 '0'과 동등합니다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 8-2. 'bool' 사용 예시"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'bool'>\n"
     ]
    }
   ],
   "source": [
    "boolval = False\n",
    "print(type(boolval))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "# 비교연산의 결과로 'bool' 값이 표시됨.\n",
    "print(1 < 2)\n",
    "print(1 > 2)\n",
    "print(1 != 2)\n",
    "print(1 == 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "False\n",
      "True\n",
      "True\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# 논리연산의 결과로 'bool' 값이 표시됨.\n",
    "print(True and False)\n",
    "print(True & False)\n",
    "print(True or False)\n",
    "print(True | False)\n",
    "print(not True)\n",
    "print(not False)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "base",
   "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"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}