{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. 리스트 [ ]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.1 리스트 만들기\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[90, 95, 85, 80]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "student1 = [90,95,85,80] \n",
    "student1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- student[0],[1],[2],[3]\n",
    "- student[-4],[-3],[-2],[-1]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[90, 100, 85, 80]"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "student1[1] = 100   # 두 번째 항목에 새로운 데이터 할당\n",
    "student1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.2 리스트 다루기\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 리스트 더하기"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 6, 7, 8]\n"
     ]
    }
   ],
   "source": [
    "list_con1= [1,2,3,4]\n",
    "list_con2 = [5,6,7,8]\n",
    "list_con = list_con1 + list_con2    # 리스트 연결\n",
    "\n",
    "print(list_con)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 리스트 곱하기"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "list_con1= [1,2,3,4]\n",
    "list_con = list_con1 * 3    # 곱한만큼 리스트 반복\n",
    "\n",
    "print(list_con)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.3 리스트 항목 다루기"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 리스트 일부 항목 가져오기"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 리스트 [시작 : 끝 : 스텝(증가단계)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
      "[0, 1, 2]\n",
      "[4, 5, 6, 7]\n",
      "[0, 1, 2]\n",
      "[7, 8, 9]\n",
      "[0, 2, 4, 6, 8]\n"
     ]
    }
   ],
   "source": [
    "list_data = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]    \n",
    "print(list_data)\n",
    "print(list_data[0:3]) \n",
    "print(list_data[4:8])\n",
    "print(list_data[:3])\n",
    "print(list_data[7:])\n",
    "print(list_data[::2])     # 2씩 증가"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 리스트 항목 삭제하기"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- del 리스트 [i]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
      "[0, 1, 2, 3, 4, 5, 7, 8, 9]\n"
     ]
    }
   ],
   "source": [
    "del list_data[6]   # [6]번 항목삭제\n",
    "print(list_data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 리스트에서 항목의 존재여부 확인하기"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 항목 in 리스트\n",
    "- 리스트에 항목있으면 true, 없으면 false"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "list_data1 = [1, 2, 3, 4, 5]\n",
    "print(5 in list_data1)       # 5가 항목에 있는지\n",
    "print(6 in list_data1)       # 6이 항목에 있는지"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.4 리스트 메서드 사용하기"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### append"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['James', 'Robert', 'Lisa', 'Mary']\n",
      "['James', 'Robert', 'Lisa', 'Mary', 'Thomas']\n"
     ]
    }
   ],
   "source": [
    "myFriends = ['James', 'Robert', 'Lisa', 'Mary']\n",
    "print(myFriends)\n",
    "myFriends.append('Thomas')   # append: 리스트 맨 끝에 새로운 항목 추가\n",
    "print(myFriends)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### insert"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['James', 'Robert', 'Lisa', 'Mary']\n",
      "['James', 'Paul', 'Robert', 'Lisa', 'Mary']\n"
     ]
    }
   ],
   "source": [
    "myFriends = ['James', 'Robert', 'Lisa', 'Mary']\n",
    "print(myFriends)\n",
    "myFriends.insert(1,'Paul')  # insert: 인덱스 1번 위치에 Paul 삽입\n",
    "print(myFriends)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### extend"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['James', 'Robert', 'Lisa', 'Mary']\n",
      "['James', 'Robert', 'Lisa', 'Mary', 'Laura', 'Betty']\n"
     ]
    }
   ],
   "source": [
    "myFriends = ['James', 'Robert', 'Lisa', 'Mary']\n",
    "print(myFriends)\n",
    "myFriends.extend(['Laura', 'Betty'])  # extend: 리스트의 맨 끝에 여러 개의 항목 추가\n",
    "print(myFriends)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. 튜플 ( )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 리스트와 다르게 한번 생성하면 항목 변경 불가 -> 메서드 사용이 힘듬"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.1 튜플 만들기"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 2, 3, 4)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tuple1 = (1,2,3,4)   # 소괄호 사용해 만들기\n",
    "tuple1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tuple1[1]  # 1번위치 튜플 출력"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(5, 6, 7, 8)\n"
     ]
    }
   ],
   "source": [
    "tuple2 = 5,6,7,8   # 소괄호 사용하지 않고도 만들수 있음\n",
    "print(tuple2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(9,)\n",
      "(10,)\n"
     ]
    }
   ],
   "source": [
    "tuple3 = (9,)     # 항목을 하나만 갖는 튜플 생성 시, 반드시 콤마 필요\n",
    "tuple4 = 10,  \n",
    "print(tuple3)\n",
    "print(tuple4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.2 튜플 메서드 사용하기"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " - index, count는 요소를 변경하지 않는 메서드라 사용가능"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tuple6 = ('a', 'b', 'c', 'd', 'e', 'f')\n",
    "tuple6.index('c')   # 인자와 일치하는 첫번째 항목의 위치 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### count"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tuple7 = ('a', 'a', 'a', 'b', 'b', 'c', 'd')\n",
    "tuple7.count('a')  # 인자와 일치하는 항목의 개수 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. 세트 { }"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.1 세트 만들기"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3}\n",
      "{1, 2, 3}\n"
     ]
    }
   ],
   "source": [
    "set1 = {1, 2, 3}\n",
    "set1a = {1, 2, 3, 3}\n",
    "print(set1)\n",
    "print(set1a)    # 중복된 데이터는 하나만 출력"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.2 교집합, 합집합, 차집합 구하기\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 메서드 이용해서"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{4, 5}"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = {1, 2, 3, 4, 5}         \n",
    "B = {4, 5, 6, 7, 8, 9, 10} \n",
    "A.intersection(B)  # 교집합(A∩B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.union(B)  # 합집합(A∪B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3}"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.difference(B) # 차집합(A-B)   #A에서 B를 지운 것"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 연산자 이용해서"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{4, 5}"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = {1, 2, 3, 4, 5}         \n",
    "B = {4, 5, 6, 7, 8, 9, 10}  \n",
    "A & B  # 교집합(A∩B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A | B  # 합집합(A∪B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3}"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A - B  # 차집합(A-B)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.4 리스트, 튜플, 세트 간 타입 변환 \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = [1,2,3,4,5]    # 리스트 a 생성"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 2, 3, 4, 5)"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = tuple(a)      # 리스트 a를 튜플 b로 변환\n",
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 4, 5}"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c = set(a)       # 리스트 a를 세트 c로 변환\n",
    "c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. 딕셔너리"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "- 쌍으로 데이터를 입력해야 할 때 사용 (키:값)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.1 딕셔너리 만들기"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 키와 값이 모두 문자열"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'영국': '런던', '프랑스': '파리', '스위스': '베른', '호주': '멜버른', '덴마크': '코펜하겐'}"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "country_capital = {\"영국\":\"런던\", \"프랑스\":\"파리\", \"스위스\": \"베른\", \"호주\":\"멜버른\", \"덴마크\": \"코펜하겐\"}  \n",
    "country_capital    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'런던'"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "country_capital[\"영국\"]   # 원하는 키의 값을 찾을 때"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 키는 숫자, 값은 문자열"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1: '버스', 3: '비행기', 4: '택시', 5: '자전거'}"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dict_data1 = {1:\"버스\", 3: \"비행기\", 4:\"택시\", 5: \"자전거\"}    \n",
    "dict_data1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'비행기'"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dict_data1[3]      # 3이 리스트의 인덱스처럼 위치를 뜻하는 것 아님\n",
    "                   # 딕셔너리의 키일 뿐"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 키와 값이 모두 숫자"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1: 10, 2: 20, 3: 30, 4: 40, 5: 50}\n",
      "40\n"
     ]
    }
   ],
   "source": [
    "dict_data2 = {1:10, 2: 20, 3:30, 4: 40, 5:50}    \n",
    "print(dict_data2)\n",
    "print(dict_data2[4])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "####  키는 문자열, 값은 리스트"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'list_data1': [11, 12, 13], 'list_data2': [21, 22, 23]}\n",
      "[21, 22, 23]\n"
     ]
    }
   ],
   "source": [
    "dict_data3 = {\"list_data1\":[11,12,13], \"list_data2\": [21,22,23]}  \n",
    "print(dict_data3)\n",
    "print(dict_data3[\"list_data2\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.2 딕셔너리 다루기"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 딕셔너리에 데이터 추가"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'영국': '런던', '프랑스': '파리', '스위스': '베른', '호주': '멜버른', '덴마크': '코펜하겐'}"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "country_capital"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'영국': '런던', '프랑스': '파리', '스위스': '베른', '호주': '멜버른', '덴마크': '코펜하겐', '독일': '베를린'}"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "country_capital[\"독일\"]= \"베를린\"    # 키=독일, 값=베를린 추가\n",
    "country_capital"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 딕셔너리의 데이터 변경"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'영국': '런던', '프랑스': '파리', '스위스': '베른', '호주': '캔버라', '덴마크': '코펜하겐', '독일': '베를린'}"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "country_capital[\"호주\"]= \"캔버라\"   #기존 호주키의 값에 변경할 값을 할당\n",
    "country_capital"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 딕셔너리의 데이터 삭제"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'영국': '런던', '프랑스': '파리', '스위스': '베른', '호주': '캔버라', '독일': '베를린'}"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "del country_capital[\"덴마크\"]    # 삭제할 키 입력\n",
    "country_capital"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.3 딕셔너리 메서드 활용하기 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 딕셔너리 메서드인 keys, values, items는 각각 dict_keys, dict_values, dict_items라는 데이터 형태로 값을 반환"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "fruit_code = {\"사과\":101, \"배\":102, \"딸기\":103, \"포도\":104, \"바나나\":105}    # 딕셔너리 생성\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_keys(['사과', '배', '딸기', '포도', '바나나'])\n"
     ]
    }
   ],
   "source": [
    "print(fruit_code.keys())     # 키만 출력"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_values([101, 102, 103, 104, 105])\n"
     ]
    }
   ],
   "source": [
    "print(fruit_code.values())   # 값만 출력"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_items([('사과', 101), ('배', 102), ('딸기', 103), ('포도', 104), ('바나나', 105)])\n"
     ]
    }
   ],
   "source": [
    "print(fruit_code.items())    # 키와 값의 쌍을 출력"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.4 딕셔너리를 list로 변환 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 딕셔너리를 list로 변환하면 데이터 처리가 편리"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['사과', '배', '딸기', '포도', '바나나']"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(fruit_code.keys())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[101, 102, 103, 104, 105]"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(fruit_code.values())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('사과', 101), ('배', 102), ('딸기', 103), ('포도', 104), ('바나나', 105)]"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(fruit_code.items())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.5 딕셔너리 활용"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### update 이용해 새로운 딕셔너리 데이터 추가"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "fruit_code2 = {\"오렌지\":106, \"수박\":107}   # 딕셔너리 생성"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'사과': 101, '배': 102, '딸기': 103, '포도': 104, '바나나': 105, '오렌지': 106, '수박': 107}"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fruit_code.update(fruit_code2)   # update 이용해 fruit_code에 fruit_code2를 추가\n",
    "fruit_code"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### clear 이용해 딕셔너리 모든 항목 삭제"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{}\n"
     ]
    }
   ],
   "source": [
    "fruit_code2.clear()    \n",
    "print(fruit_code2)     # fruit_code2의 모든 항목을 삭제해 결과값이 빈 딕셔너리{}가 됨"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}