{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n",
    "***\n",
    "# 4. 리스트, 튜플, 사전 및 내장 자료형 특성\n",
    "***\n",
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n",
    "## 1 리스트, 튜플, 사전\n",
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1-1 리스트(list)의 정의와 리스트 기본 연산\n",
    "- 리스트: 임의의 객체를 순차적으로 저장하는 집합적 자료형\n",
    "- 문자열이 지닌 대부분의 연산들은 리스트도 지원"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'list'>\n",
      "\n",
      "3\n",
      "\n",
      "2\n",
      "3\n",
      "[2, 3]\n",
      "\n",
      "[1, 2, 3, 1, 2, 3]\n",
      "[1, 2, 3, 1, 2, 3, 1, 2, 3]\n",
      "\n",
      "[1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "L = [1,2,3]\n",
    "print(type(L))\n",
    "print()\n",
    "print(len(L))\n",
    "print()\n",
    "print(L[1])\n",
    "print(L[-1])\n",
    "print(L[1:3])\n",
    "print()\n",
    "print(L + L)\n",
    "print(L * 3)\n",
    "print()\n",
    "print(L)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 리스트의 원소는 변경 가능"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10, 5, 6]\n"
     ]
    }
   ],
   "source": [
    "l1 = [4,5,6]\n",
    "l1[0] = 10\n",
    "print(l1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![image](../images/changeListElement.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 동일한 변수에 다른 리스트를 할당하는 것은 해당 변수의 레퍼런스를 변경함"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4, 5, 6]\n"
     ]
    }
   ],
   "source": [
    "l1 = [1,2,3]\n",
    "l1 = [4,5,6]\n",
    "print(l1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![image](../images/referenceChangeList.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1-2 <code>range()</code> 함수를 통한 인덱스 리스트 생성\n",
    "- <code>range(k)</code>: 0부터 k-1까지의 range object를 반환함 (python3)\n",
    "  - python2 에서는 list 객체를 반환"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "range(0, 10)\n",
      "range(0, 10, 2)\n",
      "range(9, -1, -1)\n",
      "True\n",
      "\n",
      "[0, 1, 2, 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": [
    "L = range(10)\n",
    "print(L)\n",
    "print(L[::2])\n",
    "print(L[::-1])\n",
    "print(4 in L)\n",
    "print()\n",
    "print(list(L))\n",
    "print(list(L)[::2])\n",
    "print(list(L)[::-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1-3 튜플(tuple)의 정의와 기본 연산\n",
    "- 튜플: 리스트와 유사하지만 튜플 내의 값을 변경할 수 없음(<code>immutable</code>하다.)\n",
    "  - 적합한 사용 예\n",
    "    - <code>months = ('January','February','March','April','May','June','July','August','September','October','November','  December')</code>\n",
    "    - 각 값에 대해 인덱스가 부여됨\n",
    "- 문자열이 지닌 대부분의 연산들은 튜플도 지원"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "\n",
      "1\n",
      "3\n",
      "(1, 2)\n",
      "(1, 3)\n",
      "\n",
      "(1, 2, 3, 1, 2, 3, 1, 2, 3)\n",
      "(1, 2, 3, 1, 2, 3, 1, 2, 3)\n",
      "\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "t = (1,2,3)\n",
    "\n",
    "print(len(t))\n",
    "print()\n",
    "print(t[0])\n",
    "print(t[-1])\n",
    "print(t[0:2])\n",
    "print(t[::2])\n",
    "print()\n",
    "print(t + t + t)\n",
    "print(t * 3)\n",
    "print()\n",
    "print(3 in t)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1-4 튜플의 상수적 성격\n",
    "- 튜플은 내용 변경 불가(<code>immutable</code>)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'tuple' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-6-b050fc22719c>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mt\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mt\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m100\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "t = (1,2,3)\n",
    "\n",
    "t[0] = 100"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 반면에 리스트는 내용 변경 가능(<code>mutable</code>)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[100, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "L = [1,2,3]\n",
    "L[0] = 100\n",
    "\n",
    "print(L)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1-5 사전(dictionary; dict)의 정의와 기본 사용법\n",
    "- 정수형 인덱스가 아닌 키(key)를 이용하여 값(value)을 저장하는 자료 구조\n",
    "  - 저장된 각 자료에 대한 순서는 의미 없음\n",
    "- 매핑(Mapping) 함수와 비슷한 역할을 함\n",
    "  - x라는 키값을 넣으면 값 y를 반환함"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hana\n"
     ]
    }
   ],
   "source": [
    "d = {'one': 'hana', 'two': 'dul', 'three': 'set'}\n",
    "print(d['one'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'one': 'hana', 'two': 'dul', 'three': 'set', 'four': 'net'}\n",
      "{'one': 1, 'two': 'dul', 'three': 'set', 'four': 'net'}\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "d = {'one': 'hana', 'two': 'dul', 'three': 'set'}\n",
    "d['four'] = 'net' # 새 항목의 삽입\n",
    "print(d)\n",
    "d['one'] = 1      # 기존 항목의 값 변경\n",
    "print(d)\n",
    "print('one' in d)  # 키에 대한 멤버쉽 테스트"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_keys(['one', 'two', 'three', 'four'])\n",
      "dict_values([1, 'dul', 'set', 'net'])\n",
      "dict_items([('one', 1), ('two', 'dul'), ('three', 'set'), ('four', 'net')])\n"
     ]
    }
   ],
   "source": [
    "d = {'one': 1, 'two': 'dul', 'three': 'set', 'four': 'net'}\n",
    "print(d.keys())    # 키만 dict_keys 객체로 추출(Python3.6), 키만 리스트로 추출(Python2.7)\n",
    "print(d.values())  # 값만 dict_values 객체로 추출(Python3.6), 값만 리스트로 추출(Python2.7)\n",
    "print(d.items())   # 키와 값의 튜플을 dict_items 객체로 추출(Python 3.6), 키와 값의 튜플을 리스트로 반환함(Python2.7)\n",
    "\n",
    "# ['four', 'three', 'two', 'one']\n",
    "# ['net', 'set', 'dul', 1]\n",
    "# [('four', 'net'), ('three', 'set'), ('two', 'dul'), ('one', 1)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "***\n",
    "## 2 내장 자료형의 정리와 객체 신원 파악\n",
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2-1 내장 자료형의 특성 정리"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "| 자료형 |   저장/접근 방법  | 변경 가능성 |       저장 모델      |\n",
    "|:------:|:-----------------:|:-----------:|:--------------------:|\n",
    "| 수치형 |    직접(Direct)   |     변경불가능(Immutable)    |   리터럴 (Literal)   |\n",
    "| 문자열 | 시퀀스 (Sequence) |     변경불가능(Immutable)    |   리터럴 (Literal)   |\n",
    "| 리스트 | 시퀀스 (Sequence) |     변경가능(Mutable)    | 컨테이너 (Container) |\n",
    "|  튜플  | 시퀀스 (Sequence) |     변경불가능(Immutable)    | 컨테이너 (Container) |\n",
    "|  사전  |   매핑 (Mapping)  |     변경가능(Mutable)    | 컨테이너 (Container) |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2-2 내장 자료형 알아보기"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n",
      "<class 'float'>\n",
      "<class 'str'>\n"
     ]
    }
   ],
   "source": [
    "print(type(3))       #정수\n",
    "print(type(3.3))     #실수\n",
    "print(type('abc'))   #문자열\n",
    "\n",
    "# <type 'int'>\n",
    "# <type 'float'>\n",
    "# <type 'str'>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'list'>\n",
      "<class 'tuple'>\n",
      "<class 'dict'>\n"
     ]
    }
   ],
   "source": [
    "print(type([]))      #리스트\n",
    "print(type(()))      #튜플\n",
    "print(type({}))      #사전(dict)\n",
    "\n",
    "# <type 'list'>\n",
    "# <type 'tuple'>\n",
    "# <type 'dict'>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 자료형의 비교"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "a = 0\n",
    "L = [1,2,3]\n",
    "print(type(a) == type(0))\n",
    "print(type(L) == type([]))\n",
    "print(type(L[0]) == type(0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'NoneType'>\n",
      "\n",
      "None\n",
      "<class 'NoneType'>\n"
     ]
    }
   ],
   "source": [
    "print(type(None))    # NoneType 객체, 아무 값도 없음을 나타내는 객체\n",
    "print()\n",
    "a = None\n",
    "print(a)\n",
    "print(type(a))\n",
    "\n",
    "# <type 'NoneType'>\n",
    "\n",
    "# None\n",
    "# <type 'NoneType'>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2-3 객체의 신원 식별하기"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- <code>id()</code>: 객체의 식별자를 반환한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4469734928\n",
      "4469734928\n",
      "\n",
      "4430976352\n",
      "4430976352\n",
      "\n",
      "4469735056\n",
      "4469734448\n"
     ]
    }
   ],
   "source": [
    "a = 500\n",
    "b = a\n",
    "print(id(a))\n",
    "print(id(b))\n",
    "print()\n",
    "\n",
    "# 작은 값의 정수는 계속하여 별도로 객체를 생성하지 않음\n",
    "x = 1\n",
    "y = 1\n",
    "print(id(x))\n",
    "print(id(y))\n",
    "print()\n",
    "\n",
    "# 큰 값의 정수는 별도로 객체를 생성\n",
    "x = 1000000000000000000\n",
    "y = 1000000000000000000\n",
    "print(id(x))\n",
    "print(id(y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- <code>is</code> 키워드: 두 객체의 식별자가 동일한지 테스트한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "c = [1,2,3]\n",
    "d = [1,2,3]\n",
    "print(c is d)\n",
    "\n",
    "a = 500\n",
    "b = a\n",
    "print(a is b)\n",
    "\n",
    "x = 1\n",
    "y = 1\n",
    "print(x is y)\n",
    "\n",
    "e = f = [4,5,6]\n",
    "print(e is f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- == 연산자: 두 객체의 값이 동일한지를 테스트한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "c = [1,2,3]\n",
    "d = [1,2,3]\n",
    "print(c == d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "x = 1\n",
    "y = 1\n",
    "print(x is y)\n",
    "print(id(x) == id(y))\n",
    "print(x == y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "x = 900000000\n",
    "y = 900000000\n",
    "print(x is y)\n",
    "print(id(x) == id(y))\n",
    "print(x == y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2-4. 레퍼런스 카운트 (Reference Count)와 쓰레기 수집 (Garbage Collection) \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = y = z = 100"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![image](../images/referenceCount1.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "print(x is y)\n",
    "print(y is z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "del x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![image](../images/referenceCount2.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "y = 200\n",
    "z = 300"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![image](../images/referenceCount3.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style='text-align: right;'>참고 문헌: 파이썬(열혈강의)(개정판 VER.2), 이강성, FreeLec, 2005년 8월 29일</p>"
   ]
  }
 ],
 "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.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}