ds5_save.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# 저장\n",
    "\n",
    "* Last Updated: 20171105 20170410 20161006\n",
    "\n",
    "## S.1 학습내용\n",
    "\n",
    "### S.1.1 목표\n",
    "\n",
    "* 인코딩을 이해하고, 한글을 유니코드로 파일에 저장하고, 읽을 수 있다.\n",
    "* 데이터를 json, csv 파일로 쓰고, 읽을 수 있다.\n",
    "* 데이터를 웹데이터 (url에서 읽은 데이터)를 읽어서 리스트 자료로 저장하여 연산을 할 수 있다.\n",
    "* 데이터를 NoSql로 저장하고, 사용할 수 있다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### S.1.2 목차\n",
    "\n",
    "* S.2 웹 데이터 저장\n",
    "* S.2.1 부호화\n",
    "* S.2.2 웹에서의 다국적 언어\n",
    "* S.2.2 운영체제의 인코딩\n",
    "* S.2.3 프로그래밍의 인코딩\n",
    "* S.2.4.1 인코딩 알아보기\n",
    "* S.2.4.2 인코딩 설정하기\n",
    "* S.2.4.3 인코딩 실습\n",
    "* S.3 파일\n",
    "* S.3.1 Python의 파일\n",
    "* S.3.2 JSON 파일\n",
    "* S.3.3 csv 파일\n",
    "* S.4 MongoDB\n",
    "* S.4.1 설치\n",
    "* S.4.2 MongoDB shell\n",
    "* S.4.3 pymongo\n",
    "* S.5 CouchDB\n",
    "* S.5.1 설치\n",
    "* S.5.2 cURL\n",
    "* S.5.3 데이터베이스\n",
    "* S.5.4 View\n",
    "* S.5.5 Shows\n",
    "* S.5.6 Replication"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### S.1.3 문제\n",
    "\n",
    "* 문제 S-1: 음악 검색결과를 파일저장\n",
    "* 문제 S-2: 사용자 ID, 이름을 JSON형식으로 파일에 쓰기\n",
    "* 문제 S-3: JSON 파일을 읽기\n",
    "* 문제 S-4: url에서 JSON을 읽기\n",
    "* 문제 S-5: url에서 파일을 가져와 자료구조에 저장하기\n",
    "* 문제 S-6: MongoDB에 'id', '이름'을 저장하고, 조회하는 프로그램을 실행하기\n",
    "* 문제 S-7: Python으로 MongoDB Persons 조회하기\n",
    "* 문제 S-8: 음악 검색결과를 MongoDB 저장\n",
    "* 문제 S-9: CouchDB로 html 페이지 저장하기\n",
    "\n",
    "### S.1.4 연습\n",
    "\n",
    "* 웹크롤링 데이터를 MongoDB로 저장한다.\n",
    "\n",
    "* 한글 https://wiki.python.org/moin/PrintFails"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## S.2 웹 데이터 저장\n",
    "\n",
    "웹에서 수집한 데이터는 수집하는 대로, 이른바 streaming하면서 분석할 수 있다.\n",
    "그러나 기계학습을 적용하려면 일정 분량의 저장된 훈련데이터가 필요하게 된다.\n",
    "웹에서 수집한 텍스트, 사진, 음성과 같은 데이터를 컴퓨터는 어떻게 저장하고 표현하는지 알아보자."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### S.2.1 부호화\n",
    "\n",
    "데이터는 우리 눈에 보이는 대로 저장되지 않는다.\n",
    "이진수는 컴퓨터 언어이다. 이진수로 쓰고, 읽고, 전달하고 처리한다. 컴퓨터는 무엇이든 이진수로 저장한다.\n",
    "텍스트 또는 그림, 음악 등을 code points로 변환하는 것을 부호화, encoding이라고 한다.\n",
    "우리가 많이 생산하는 텍스트에 대해 알아 보자.\n",
    "텍스트는 문자로 구성되어 있고, 문자는 대응하는 '코드'를 가지고 있다.\n",
    "사람에게는 문자이지만 컴퓨터는 '코드'이다.\n",
    "'A'는 사람이 사용하는 문자이고, 컴퓨터에게는 코드 또는 부호 '65'이다 (편의상 10진수를 사용한다).\n",
    "\n",
    "용어 | 설명 | 예\n",
    "-----|-----|-----\n",
    "문자 | 텍스트의 가장 작은 단위, Character | 'A' 'B'\n",
    "부호 | 문자를 표현하는 코드 값 Code points. | 1 바이트는 0~255, unicode는 최대 4 바이트\n",
    "인코딩 | 문자를 코드 값 Code points로 변환. 디코딩은 사람이 인식할 수 있는 문자로 변환 | 'a' = 97 (ASCII 코드 값)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "많이 사용하고 있는 인코딩 방식은 ASCII, Unicode가 있다.\n",
    "\n",
    "인코딩 방식 | 설명\n",
    "----------|----------\n",
    "ASCII | 1 바이트 가운데 7비트, $2^7$, 128 문자를 표현할 수 있다. Extended ASCII는 확장해서 8비트, 256 문자를 부호값으로 표현한다.\n",
    "Unicode | 최대 4바이트로 문자를 표현하는 code points. UTF-8, UTF-16, UTF-32가 많이 쓰인다. 뒤 숫자는 비트를 의미.\n",
    "\n",
    "> UTF-8\n",
    "\n",
    "> 가장 많이 사용하는 Unicode 인코딩 방식이다.\n",
    "> HTML, XML은 utf-8을 기본 설정으로 사용한다.위키피디아에 따르면, 2017년 기준 웹의 약 90%가 utf-8을 사용한다.\n",
    "> 가변 길이로 4 바이트까지 사용한다. 처음 1~128은 ASCII와 동일하게 구성한다.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### S.2.2 웹에서의 다국적 언어\n",
    "\n",
    "* 여러 언어가 쓰인 웹페이지를 읽어서 화면에 올바르게 출력되는지 살펴본다.\n",
    "* 유니코드가 지원되면 깨지지 않고 올바르게 나타날 수 있다.\n",
    "* 간편하게 curl을 사용하거나, 웹에서 페이지를 열어보자.\n",
    "\n",
    "```\n",
    "http://httpbin.org/encoding/utf8\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Python 라이브러리 'requests'를 사용해서 출력하면 어떤지 살펴 보자.\n",
    "가져온 웹페이지에서 앞 500문자를 읽었다.\n",
    "암호같은 기호가 많이 눈에 띄인다.\n",
    "이런 기호 앞 'u'는 unicode라는 뜻이고, 그 4자리 부호가 뒤따르고 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "u'<h1>Unicode Demo</h1>\\n\\n<p>Taken from <a\\nhref=\"http://www.cl.cam.ac.uk/~mgk25/ucs/examples/UTF-8-demo.txt\">http://www.cl.cam.ac.uk/~mgk25/ucs/examples/UTF-8-demo.txt</a></p>\\n\\n<pre>\\n\\nUTF-8 encoded sample plain-text file\\n\\u203e\\u203e\\u203e\\u203e\\u203e\\u203e\\u203e\\u203e\\u203e\\u203e\\u203e\\u203e\\u203e\\u203e\\u203e\\u203e\\u203e\\u203e\\u203e\\u203e\\u203e\\u203e\\u203e\\u203e\\u203e\\u203e\\u203e\\u203e\\u203e\\u203e\\u203e\\u203e\\u203e\\u203e\\u203e\\u203e\\n\\nMarkus Kuhn [\\u02c8ma\\u02b3k\\u028as ku\\u02d0n] <http://www.cl.cam.ac.uk/~mgk25/> \\u2014 2002-07-25\\n\\n\\nThe ASCII compatible UTF-8 encoding used in this plain-text file\\nis defined in Unicode, ISO 10646-1, and RFC 2279.\\n\\n\\nUsing Unicode/UTF-8, you can write in emails and so'"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import requests\n",
    "r = requests.get(\"http://httpbin.org/encoding/utf8\")\n",
    "r.text[0:500]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Unicode가 섞여 있는 부분, 대략 200 ~ 300 정도의 문자열만 출력해 보자.\n",
    "Python print문은 Unicode를 올바르게 출력한다.\n",
    "Python 화면출력이 유니코드를 올바르게 출력하도록 설정되어 있기 때문이다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "e plain-text file\n",
      "‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾\n",
      "\n",
      "Markus Kuhn [ˈmaʳkʊs kuːn] <http://www.cl.ca\n"
     ]
    }
   ],
   "source": [
    "print r.text[200:300]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "위 문자를 화면에 출력할 때 오류가 발생할 수 있다. 이런 'UnicodeEncodeError' 오류는 유니코드를 화면에 출력할 수 없기 때문에 발생한다. 'sys.stdout.encoding'를 확인하자."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "UTF-8\n"
     ]
    }
   ],
   "source": [
    "import sys\n",
    "print sys.stdout.encoding   # locale LC_CTYPE"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### S.2.3 운영체제의 인코딩\n",
    "\n",
    "인코딩은 운영체제에서 지원하는 형식을 가져와서 Python과 같은 프로그래밍 언어에서 사용하게 된다.\n",
    "운영체제에서 지원하는 인코딩 방식을 알아 보자.\n",
    "결론부터 말하면, 가능하면 unicode를 사용하도록 한다.\n",
    "윈도우 운영체제는 unicode를 기본으로 지원하지 않을 수 있다.\n",
    "locale을 'utf-8'로 정의하도록 한다.\n",
    "\n",
    "> 한글 부호표준\n",
    "> 한글을 사용하면서 EUC-KR 또는 CP949 부호를 만나게 된다.\n",
    "> EUC-KR, CP949는 2바이트로 한글을 표현하는 표준이다.\n",
    "> 윈도우는 CP949를 기본으로 사용한다. 인터넷에서 CP949를 유니코드로 인식해서 처리하면 오류가 발생할 수 있다.\n",
    "> 지금은 유니코드가 주로 사용된다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "운영체제 locale을 알아본다. UTF-8이 아닌 경우 유니코드를 출력할 수 없으므로 설정을 변경하도록 한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('en_US', 'UTF-8')"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import locale\n",
    "locale.getdefaultlocale()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* 운영체제 locale의 설정을 확인한다.\n",
    "* 윈도우에서는 '제어판 > 언어' 또는 명령창에서 'systeminfo.exe'를 사용하면 '시스템 로캘', '입력 로캘'을 보여준다.\n",
    "* 문자, 통화, 시간, 숫자, 언어에 대해 주요 환경변수 설정이다. LC_ALL은 비워져 설정이 되어 있지 않다.\n",
    "\n",
    "구분 | 설명\n",
    "-----|-----\n",
    "LC_ALL | 모든 locale 변수의 값보다 우선한다. 기본 값은 비워 놓는다.\n",
    "LC_CTYPE | 문자 분류와 대소문자 변환을 정의\n",
    "LC_MONETARY | 통화 숫자 정보의 형식을 정의\n",
    "LC_NUMERIC | 숫자, 비-통화 형식을 정의\n",
    "LC_TIME | 날짜 및 시간 형식을 정의\n",
    "LANG | LC_ALL이 설정되지 않은 경우, LANG 값은 언어, 문자 세트, 정렬 순서를 판별"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LANG=en_US.UTF-8\r\n",
      "LANGUAGE=en_US:en\r\n",
      "LC_CTYPE=\"en_US.UTF-8\"\r\n",
      "LC_NUMERIC=ko_KR.UTF-8\r\n",
      "LC_TIME=ko_KR.UTF-8\r\n",
      "LC_COLLATE=\"en_US.UTF-8\"\r\n",
      "LC_MONETARY=ko_KR.UTF-8\r\n",
      "LC_MESSAGES=\"en_US.UTF-8\"\r\n",
      "LC_PAPER=ko_KR.UTF-8\r\n",
      "LC_NAME=ko_KR.UTF-8\r\n",
      "LC_ADDRESS=ko_KR.UTF-8\r\n",
      "LC_TELEPHONE=ko_KR.UTF-8\r\n",
      "LC_MEASUREMENT=ko_KR.UTF-8\r\n",
      "LC_IDENTIFICATION=ko_KR.UTF-8\r\n",
      "LC_ALL=\r\n"
     ]
    }
   ],
   "source": [
    "!locale"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### S.2.4 프로그래밍의 인코딩\n",
    "\n",
    "#### S.2.4.1 인코딩 알아보기\n",
    "\n",
    "* 운영체제에서 지원하는 인코딩을 가져와서 사용한다.\n",
    "* Python print문은 운영체제에서 설정된, locale.getpreferredencoding()을 사용한다.\n",
    "    * locale은 utf-8을 사용하므로, 출력하면 unicode를 이해하고 출력한다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* Python 인코딩 방식은 sys.getdefaultencoding() 명령문으로 알아볼 수 있다.\n",
    "* Python 2.x는 'ascii'를 기본으로 사용하고 있다. 의 결과가 'ascii'이다.\n",
    "* Python 3은 utf-8을 기본 설정으로 사용한다 (when LC_CTYPE is unicode-aware)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "UTF-8\n",
      "ascii\n"
     ]
    }
   ],
   "source": [
    "import sys, locale\n",
    "print locale.getpreferredencoding()\n",
    "print sys.getdefaultencoding()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* Python os.environ의 LANG이 설정되어 있다.\n",
    "* 이 값은 운영체제 locale.LANG과 동일한 값을 가지고 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'en_US.UTF-8'"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import os\n",
    "os.environ['LANG']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### S.2.4.2 인코딩  설정하기\n",
    "\n",
    "* Python의 기본 encoding을 변경할 수 있다.\n",
    "* 환경변수를 정해 놓을 수 있다.\n",
    "```\n",
    "export PYTHONIOENCODING=utf-8\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import locale\n",
    "locale.setlocale(locale.LC_ALL, 'en_US.utf-8')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "import sys\n",
    "reload(sys)\n",
    "sys.setdefaultencoding('utf-8')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### S.2.4.3 인코딩 실습\n",
    "\n",
    "예를 들어 보자. 문자열 'AB한글'은 영어 2글자, 한글 2글자 이다.\n",
    "영어 'AB'는 ASCII 문자이다. 반면에 '한글'은 ASCII 문자가 아니다.\n",
    "ASCII 문자는 0~127 부호 값을 가진다.\n",
    "반면 128 이상, 즉 '한글'은 ASCII 부호 값이 없다.\n",
    "\n",
    "한글이 포함되어도 문자 타잎은 'str'이다.\n",
    "그러나 한글이 포함된 경우 오류가 발생할 수 있으므로 'unicode'를 사용하도록 한다.\n",
    "\n",
    "데이터 타잎 | 설명 | 예\n",
    "-----|-----|-----\n",
    "str | ASCII, 1~128 범위를 가진다. \\x로 시작 2자리 (1바이트) | '한' '\\xed\\x95\\x9c'\n",
    "unicode | 유니코드, 최대 4 바이트, \\u로 시작 4자리 | '한' u'\\ud55c'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\xed\\x95\\x9c'"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str('한')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "u'\\ud55c'"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "unicode(u'한')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* 한글은 Non-ASCII이다. ASCII에서 unicode로 encoding할 수 없다. \n",
    "* '한'은 ASCII 코드 값 Code points가 없기 때문에 오류가 발생한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "ename": "UnicodeDecodeError",
     "evalue": "'ascii' codec can't decode byte 0xed in position 0: ordinal not in range(128)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mUnicodeDecodeError\u001b[0m                        Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-91-872cdbea1ae2>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;34m'한'\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mencode\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'utf-8'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mUnicodeDecodeError\u001b[0m: 'ascii' codec can't decode byte 0xed in position 0: ordinal not in range(128)"
     ]
    }
   ],
   "source": [
    "'한'.encode('utf-8')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\xed\\x95\\x9c'"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(u'한').encode('utf-8')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\xc7\\xd1'"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(u'한').encode('cp949')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* stdout encoding 'utf-8'에 따라 출력한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "한\n"
     ]
    }
   ],
   "source": [
    "print u'한'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "영어문자는 각 1바이트, 한글은 각 3바이트를 사용한다. 따라서 8바이트가 된다. ASCII는 코드 값 127까지 가진다. 128이상은 설정된 인코딩 방식, 보통 utf-8을 사용하여 변환한다.\n",
    "\n",
    "format()은 형식을 정해서 출력하는 기능이다. 인자는 {}, 괄호 내에 순서, 콜론으로 변환형식을 정의할 수 있다. 다음은 2진수, 16진수, 10진수로 출력하고 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<type 'str'>\n"
     ]
    }
   ],
   "source": [
    "myStr='AB한글'\n",
    "print type(myStr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "length in bytes:  8\n",
      " 1000001 41 65\n",
      " 1000010 42 66\n",
      "11101101 ed 237\n",
      "10010101 95 149\n",
      "10011100 9c 156\n",
      "11101010 ea 234\n",
      "10111000 b8 184\n",
      "10000000 80 128\n"
     ]
    }
   ],
   "source": [
    "print \"length in bytes: \", len(myStr)\n",
    "for e in myStr:\n",
    "    print \"{0:8b} {0:x} {0:d}\".format(ord(e))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<type 'unicode'>\n"
     ]
    }
   ],
   "source": [
    "myUnicode=u'AB한글'\n",
    "print type(myUnicode)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "length in bytes:  4\n",
      " 1000001 41 65\n",
      " 1000010 42 66\n",
      "1101010101011100 d55c 54620\n",
      "1010111000000000 ae00 44544\n"
     ]
    }
   ],
   "source": [
    "print \"length in bytes: \", len(myUnicode)\n",
    "for e in myUnicode:\n",
    "    print \"{0:8b} {0:x} {0:d}\".format(ord(e))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "utf-8와 cp949로 출력해 본다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "AB한글\n",
      "AB�ѱ�\n"
     ]
    }
   ],
   "source": [
    "for cp in ['utf-8', 'cp949']:\n",
    "    print myUnicode.encode(cp)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## S.3 파일\n",
    "\n",
    "### S.3.1 Python 파일\n",
    "\n",
    "* 'File' 객체를 사용한다 (C언어의 stdio에서 제공하는 file 참조)\n",
    "* IOError 예외가 발생할 수 있다.\n",
    "* 'File' 객체는 iterator, factory 패턴을 구현하고 있다.\n",
    "* next()함수는 iterator이다.\n",
    "* 생성자 file()을 직접 사용하여 생성할 수 있으나, 'factory' 함수를 사용하는 것을 권고한다.\n",
    "\n",
    "함수 | 설명 | 반환 returns\n",
    "-----|-----|-----\n",
    "open() | built-in' 함수이다. 파일명과 선택적으로 mode, buffering을 정할 수 있다. | File 객체\n",
    "io.open() | stream을 처리하는 'io' 라이브러리 함수이다. 추가적인 인자로 encoding, newline을 설정할 수 있다. | File 객체"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "import iplantuml"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "image/svg+xml": [
       "<svg height=\"129px\" style=\"width:68px;height:129px;\" version=\"1.1\" viewBox=\"0 0 68 129\" width=\"68px\" xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\"><defs><filter height=\"300%\" id=\"f1\" width=\"300%\" x=\"-1\" y=\"-1\"><feGaussianBlur result=\"blurOut\" stdDeviation=\"2.0\"/><feColorMatrix in=\"blurOut\" result=\"blurOut2\" type=\"matrix\" values=\"0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 .4 0\"/><feOffset dx=\"4.0\" dy=\"4.0\" in=\"blurOut2\" result=\"blurOut3\"/><feBlend in=\"SourceGraphic\" in2=\"blurOut3\" mode=\"normal\"/></filter></defs><g><rect fill=\"#FEFECE\" filter=\"url(#f1)\" height=\"112.0234\" style=\"stroke: #A80036; stroke-width: 1.5;\" width=\"53\" x=\"6\" y=\"8\"/><ellipse cx=\"21\" cy=\"24\" fill=\"#ADD1B2\" rx=\"11\" ry=\"11\" style=\"stroke: #A80036; stroke-width: 1.0;\"/><path d=\"M23.9688,29.6406 Q23.3906,29.9375 22.75,30.0859 Q22.1094,30.2344 21.4063,30.2344 Q18.9063,30.2344 17.5859,28.5859 Q16.2656,26.9375 16.2656,23.8125 Q16.2656,20.6875 17.5859,19.0313 Q18.9063,17.375 21.4063,17.375 Q22.1094,17.375 22.7578,17.5313 Q23.4063,17.6875 23.9688,17.9844 L23.9688,20.7031 Q23.3438,20.125 22.75,19.8516 Q22.1563,19.5781 21.5313,19.5781 Q20.1875,19.5781 19.5,20.6484 Q18.8125,21.7188 18.8125,23.8125 Q18.8125,25.9063 19.5,26.9766 Q20.1875,28.0469 21.5313,28.0469 Q22.1563,28.0469 22.75,27.7734 Q23.3438,27.5 23.9688,26.9219 L23.9688,29.6406 Z \"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"12\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"21\" x=\"35\" y=\"28.1543\">File</text><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"7\" x2=\"58\" y1=\"40\" y2=\"40\"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"11\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"32\" x=\"12\" y=\"54.2104\">name</text><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"11\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"32\" x=\"12\" y=\"67.0151\">mode</text><line style=\"stroke: #A80036; stroke-width: 1.5;\" x1=\"7\" x2=\"58\" y1=\"73.6094\" y2=\"73.6094\"/><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"11\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"34\" x=\"12\" y=\"87.8198\">read()</text><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"11\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"36\" x=\"12\" y=\"100.6245\">write()</text><text fill=\"#000000\" font-family=\"sans-serif\" font-size=\"11\" lengthAdjust=\"spacingAndGlyphs\" textLength=\"38\" x=\"12\" y=\"113.4292\">close()</text></g></svg>"
      ],
      "text/plain": [
       "<IPython.core.display.SVG object>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%plantuml\n",
    "@startuml\n",
    "class File {\n",
    "    name\n",
    "    mode\n",
    "    encoding\n",
    "    closed\n",
    "    file()\n",
    "    read()\n",
    "    write()\n",
    "    flush()\n",
    "    next()\n",
    "    close()\n",
    "}\n",
    "@enduml"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* mode\n",
    "\n",
    "mode | 설명\n",
    "-----|-----\n",
    "r | 읽기 (default)\n",
    "w | 쓰기\n",
    "a | 뒤에 붙이기\n",
    "b | 바이너리 bytes\n",
    "t | 텍스트 (default)\n",
    "+ | 수정"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 문제 S-1: 음악 검색결과를 파일저장\n",
    "\n",
    "앞 장에서 스크레이핑을 하고 그 결과를 화면에 출력하였다.\n",
    "여기서는 그 결과를 파일에 저장한다.\n",
    "다음에는 저장한 결과를 분석하게 된다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "프로그램에 한글이 섞여 있으므로, '# encoding:utf-8'\n",
    "format()함수를 사용하여 한글문자열을 구성할 때 unicode로 해준다.\n",
    "파일에 출력할 때도 encoding을 'utf-8'로 맞추어 준다.\n",
    "간편하게 'codes'를 사용하여 파일에 저장할 수도 있다.\n",
    "\n",
    "검색결과에 컴마 및 공백이 다수 포함되어 있다.\n",
    "csv는 올바른 출력형식이 아니다. tab으로 분리하기로 한다. 또한 줄바꿈을 넣었다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting src/ds5_1_naverMusicSave.py\n"
     ]
    }
   ],
   "source": [
    "%%writefile src/ds5_1_naverMusicSave.py\n",
    "#!\n",
    "# encoding:utf-8\n",
    "import requests\n",
    "from bs4 import BeautifulSoup\n",
    "\n",
    "pageNo=1\n",
    "p = {\"query\": u\"비오는\",\"target\":\"track\", \"page\":pageNo}\n",
    "naverUrl=\"http://music.naver.com/search/search.nhn?\"\n",
    "\n",
    "def saveMusicBS():\n",
    "    try:\n",
    "        fout=open('ds5_1_naverMusicSave.txt','w')\n",
    "        for pageNo in range(2):\n",
    "            p = {\"query\": u\"비오는\",\"target\":\"track\", \"page\":pageNo}\n",
    "            r = requests.get(naverUrl,params=p)\n",
    "            soup=BeautifulSoup(r.text,\"lxml\")\n",
    "            _selName = [title.get_text().strip() for title in soup.select('._tracklist_move > .name > a.title')]\n",
    "            _selArtist = [artist.get_text().strip() for artist in soup.select('._artist.artist')]\n",
    "            _selAlbum= [album.get_text().strip() for album in soup.select('.album > a')]\n",
    "            print \"total number of items:\",len(_selName)\n",
    "            for i in range(len(_selName)):\n",
    "                row=u\"{0}\\t{1}\\t{2}\\t{3}\\n\".format(pageNo,_selArtist[i],_selName[i],_selAlbum[i])\n",
    "                fout.write(row.encode('utf-8'))\n",
    "        fout.close()\n",
    "    except requests.exceptions.HTTPError as e:\n",
    "        print e\n",
    "        sys.exit(1)\n",
    "\n",
    "def main():\n",
    "    saveMusicBS()\n",
    "\n",
    "if __name__==\"__main__\":\n",
    "    main()\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### S.3.2 JSON 파일\n",
    "\n",
    "* JSON은 데이터를 저장하는 형식이다.\n",
    "* JSON은 schema free, 저장할 데이터 구조를 정하지 않아도 된다. 참고로 XML은 XSD를 사용해 구조를 미리 정할 수 있다.\n",
    "* JSON은 자바스크립트에서 사용하는 형식이다 (JavaScript Object Notation).\n",
    "* Javascript뿐만 아니라, 다른 프로그래밍 언어도 JSON을 많이 사용한다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* JSON 형식\n",
    "    * 형식은 key와 value의 쌍으로 이루어져 있다.\n",
    "    * 콜론으로 구분하여 key, value를 구성한다.\n",
    "    * id='405'의 JSON 예:\n",
    "```\n",
    "\"id\": \"405\"\n",
    "```\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* JSON 객체\n",
    "    * JSON 객체로 key, value를 저장할 수 있다.\n",
    "    * key가 ASCII문자이면 'str', non-ASCII 문자가 포함되면 'unicode'로 변환된다.\n",
    "    * JSON은 Python dict와 서로 호환된다.\n",
    "    * id:405 및 name:js인 JSON 객체의 예:\n",
    "```\n",
    "{ \"id\": \"405\", \"name\": \"js\" }\n",
    "```\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* key의 데이터타잎을 확인한다. key가 한글일 경우, 즉 Non-ASCII문자를 포함하고 있으면 'unicode'를 출력한다.\n",
    "* '\\x'는 16진수, '\\u'는 unicode이다.\n",
    "* ord()는 ordinal integer, hex()는 16진수를 출력하는 함수이다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'id': '405', 'name': 'js'}\n",
      "{'id': '405', '\\xec\\x9d\\xb4\\xeb\\xa6\\x84': 'js'}\n",
      "{u'\\uc774\\ub984': 'js', 'id': '405'}\n"
     ]
    }
   ],
   "source": [
    "import json\n",
    "\n",
    "user1={ \"id\": \"405\", \"name\": \"js\" }\n",
    "user2={ \"id\": \"405\", \"이름\": \"js\" }\n",
    "user3={ \"id\": \"405\", u\"이름\": \"js\" }\n",
    "\n",
    "print user1\n",
    "print user2\n",
    "print user3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false,
    "scrolled": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "이\n",
      "236\n",
      "0xec\n"
     ]
    }
   ],
   "source": [
    "print '\\xec\\x9d\\xb4'\n",
    "print ord('\\xec')\n",
    "print hex(ord('\\xec'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<type 'dict'>\n"
     ]
    }
   ],
   "source": [
    "print type(user1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "* JSON Array\n",
    "    * value가 배열을 가질 수 있다. 이 경우 배열은 Python list로 구성한다.\n",
    "```\n",
    "[ { ... } ]\n",
    "```\n",
    "\n",
    "    * key는 'Persons', value는 배열로 구성한 예:\n",
    "```\n",
    "{\"Persons\":[\n",
    "    {\"id\":\"405\", \"name\":\"js1\"},\n",
    "    {\"id\":\"406\", \"name\":\"js2\"},\n",
    "]}\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Persons': [{'id': '405', 'name': 'js1'}, {'id': '406', 'name': 'js2'}]}\n"
     ]
    }
   ],
   "source": [
    "import json\n",
    "\n",
    "p={\"Persons\":[\n",
    "    {\"id\":\"405\", \"name\":\"js1\"},\n",
    "    {\"id\":\"406\", \"name\":\"js2\"},\n",
    "]}\n",
    "\n",
    "print p"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* JSON 파일 함수\n",
    "    * 함수의 맨끝 's'를 string으로 생각하면 편리하다.\n",
    "\n",
    "함수 | 설명\n",
    "-----|-----\n",
    "loads() | JSON을 문자열에서 읽기\n",
    "dumps() | JSON을 문자열로 쓰기\n",
    "load() | JSON을 파일에서 읽기\n",
    "dump() | JSON을 파일에 쓰기\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 문제 S-2: 사용자 ID, 이름을 JSON형식으로 파일에 쓰기\n",
    "\n",
    "* 파일 확장자 .json\n",
    "* 문자열로 변환할 경우, dumps()를 사용한다.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\"Persons\": [{\"id\": \"405\", \"\\uc774\\ub984\": \"js1\"}, {\"id\": \"406\", \"\\uc774\\ub984\": \"js2\"}]}\n"
     ]
    }
   ],
   "source": [
    "import json\n",
    "\n",
    "p={\"Persons\":[\n",
    "    {\"id\":\"405\", \"이름\":\"js1\"},\n",
    "    {\"id\":\"406\", \"이름\":\"js2\"},\n",
    "]}\n",
    "\n",
    "print json.dumps(p)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* key가 한글이면 Non-ASCII이므로 unicode로 변환된다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "import io, json\n",
    "with io.open('data/ds_save_persons.json', 'w', encoding='utf8') as json_file:\n",
    "    data=json.dumps(p, json_file, ensure_ascii=False, encoding='utf8')\n",
    "    json_file.write(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* 방금 dumps()를 사용해서 문자열을 파일로 보냈다. 이번에는 문자열로 만들지 않고 dump()를 사용해서 바로 파일로 써보자.\n",
    "    * 동일한 명령문으로 실행하면 오류가 발생한다.\n",
    "    \n",
    ">    * 버그: Python 2.x 문제가 있다. TypeError가 발생한다 ('unicode'대신 'str'을 사용해야 한다는 오류)\n",
    ">    * io.open() 대신 open()을 사용하면 오류를 피할 수 있다. Python 3으로 전환되면서 문제가 있는 듯하다.\n",
    ">        * Python 2.6에서 'unicode'처리를 위해 'io' 모듈을 추가해서 codes.open()를 대체했다.\n",
    ">        * Python 3.x에서는 io.open()을 사용하는 것을 권고하고 있다.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false,
    "scrolled": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "write() argument 1 must be unicode, not str",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-26-691277c97dce>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mos\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mio\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mjson\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;32mwith\u001b[0m \u001b[0mio\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mopen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mos\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpath\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mjoin\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'data'\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m'ds_save_persons.json'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'w'\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mjson_file\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m     \u001b[0mjson\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdump\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mp\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mjson_file\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mencoding\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m\"utf-8\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m/usr/lib/python2.7/json/__init__.pyc\u001b[0m in \u001b[0;36mdump\u001b[0;34m(obj, fp, skipkeys, ensure_ascii, check_circular, allow_nan, cls, indent, separators, encoding, default, sort_keys, **kw)\u001b[0m\n\u001b[1;32m    188\u001b[0m     \u001b[0;31m# a debuggability cost\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    189\u001b[0m     \u001b[0;32mfor\u001b[0m \u001b[0mchunk\u001b[0m \u001b[0;32min\u001b[0m \u001b[0miterable\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 190\u001b[0;31m         \u001b[0mfp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwrite\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mchunk\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    191\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    192\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mTypeError\u001b[0m: write() argument 1 must be unicode, not str"
     ]
    }
   ],
   "source": [
    "import os, io, json\n",
    "with io.open(os.path.join('data','ds_save_persons.json'), 'w') as json_file:\n",
    "    json.dump(p, json_file, encoding=\"utf-8\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* with 명령어는 설정을 정의하는 명령어 이다.\n",
    "* with 명령어로 생성된 파일은 close()를 호출해서 닫지 않아도 된다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "import json, os\n",
    "with open(os.path.join('data','ds_save_persons.json'), 'w') as json_file:\n",
    "    json.dump(p, json_file)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\"Persons\": [{\"id\": \"405\", \"\\uc774\\ub984\": \"js1\"}, {\"id\": \"406\", \"\\uc774\\ub984\": \"js2\"}]}"
     ]
    }
   ],
   "source": [
    "!cat data/ds_save_persons.json"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "import os, json\n",
    "json_file=open(os.path.join('data','ds_save_persons.json'), 'w')\n",
    "json.dump(p, json_file)\n",
    "json_file.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\"Persons\": [{\"id\": \"405\", \"\\uc774\\ub984\": \"js1\"}, {\"id\": \"406\", \"\\uc774\\ub984\": \"js2\"}]}"
     ]
    }
   ],
   "source": [
    "!cat data/ds_save_persons.json"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 문제 S-3: JSON 파일을 읽기\n",
    "\n",
    "* file에서 JSON 문자열을 읽어오는 경우\n",
    "\n",
    "* loads()함수로 json을 읽는다.\n",
    "    * Persons json을 파일에서 읽는다.\n",
    "    * json.loads()는 문자열을 반환한다 ('str' 또는 'unicode').\n",
    "    * 한 번 더 json.loads()를 하면, unicode -> dictionary로 변환한다.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "import os, json\n",
    "fp=open(os.path.join('data','ds_save_persons.json'),'r')\n",
    "data=fp.read()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\"Persons\": [{\"id\": \"405\", \"\\uc774\\ub984\": \"js1\"}, {\"id\": \"406\", \"\\uc774\\ub984\": \"js2\"}]}\n"
     ]
    }
   ],
   "source": [
    "print data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false,
    "scrolled": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{u'Persons': [{u'\\uc774\\ub984': u'js1', u'id': u'405'}, {u'\\uc774\\ub984': u'js2', u'id': u'406'}]}\n"
     ]
    }
   ],
   "source": [
    "pjson=json.loads(data)\n",
    "print pjson"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(pjson)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "405 js1\n",
      "406 js2\n"
     ]
    }
   ],
   "source": [
    "for p in pjson['Persons']:\n",
    "    print p['id'], p[u'이름']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* 방금 사용했던 loads()를 사용했다. 즉 파일에서 읽은 문자열을 json으로 변환하는 과정을 거쳤다.\n",
    "* load()를 직접 사용하여 파일에서 dict를 받아와 보자."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": false,
    "scrolled": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<type 'dict'> {u'Persons': [{u'\\uc774\\ub984': u'js1', u'id': u'405'}, {u'\\uc774\\ub984': u'js2', u'id': u'406'}]}\n"
     ]
    }
   ],
   "source": [
    "import json\n",
    "import os\n",
    "with open(os.path.join('data','ds_save_persons.json')) as json_data:\n",
    "    d = json.load(json_data)\n",
    "    print type(d), d\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* key, value에 u는 유니코드를 의미한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "405 js1\n",
      "406 js2\n"
     ]
    }
   ],
   "source": [
    "for p in d['Persons']:\n",
    "    print p['id'], p[u'이름']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'name': 'A', 'primary_key': 1}"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import json, ast\n",
    "r = {u'name': u'A', u'primary_key': 1}\n",
    "ast.literal_eval(json.dumps(r))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "* JSON을 url에서 읽을 경우\n",
    "\n",
    "함수 | 설명\n",
    "-----|-----\n",
    "json.load(response) | file 객체와 같은 'response'를 사용해서 읽는 load() 함수\n",
    "json.loads(response.read()) | response.read()에서 반환한 문자열을 읽는 loads() 함수\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 문제 S-4: url에서 JSON을 읽기\n",
    "\n",
    "* url에 데이터가 저장되어 있는 구조를 먼저 확인해야 한다.\n",
    "    * 사례1: list > 그 안에는 dictionary로 저장\n",
    "    * 사례2: dict > meta, data > data 안에는 key없이 값만 list로 저장 (key는 meta에 저장)\n",
    "* requests 라이브러리는 response를 json으로 읽는 기능을 제공한다.\n",
    "\n",
    "```\n",
    "import requests\n",
    "r = requests.get(url)\n",
    "r.json()\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* 사례1: 월드컵 참가 선수 데이터\n",
    "    * JSON 배열\n",
    "\n",
    "```\n",
    "[\n",
    "  {\n",
    "    \"Competition\": \"World Cup\",\n",
    "    \"Year\": 1930,\n",
    "    \"Team\": \"Argentina\",\n",
    "    \"Number\": \"\",\n",
    "    \"Position\": \"GK\",\n",
    "    \"FullName\": \"Ãngel Bossio\",\n",
    "    \"Club\": \"Club AtlÃ©tico Talleres de Remedios de Escalada\",\n",
    "    \"ClubCountry\": \"Argentina\",\n",
    "    \"DateOfBirth\": \"1905-5-5\",\n",
    "    \"IsCaptain\": false\n",
    "  },\n",
    "  ...\n",
    "]\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "import requests\n",
    "_url=\"https://raw.githubusercontent.com/jokecamp/FootballData/master/World%20Cups/all-world-cup-players.json\"\n",
    "r=requests.get(_url)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "if r.status_code==200:\n",
    "    _json=r.json()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "list"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(_json)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[u'Club', u'ClubCountry', u'Year', u'Number', u'Competition', u'DateOfBirth', u'Team', u'Position', u'FullName', u'IsCaptain']\n"
     ]
    }
   ],
   "source": [
    "print _json[0].keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{u'Club': u'Club Atl\\xc3\\xa9tico Talleres de Remedios de Escalada', u'ClubCountry': u'Argentina', u'Year': 1930, u'Number': u'', u'Competition': u'World Cup', u'DateOfBirth': u'1905-5-5', u'Team': u'Argentina', u'Position': u'GK', u'FullName': u'\\xc3ngel Bossio', u'IsCaptain': False}\n"
     ]
    }
   ],
   "source": [
    "print _json[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* for 문을 사용하여 json을 읽어 보자."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " 0 Ãngel Bossio Club AtlÃ©tico Talleres de Remedios de Escalada\n",
      "1 Juan Botasso Quilmes AtlÃ©tico Club\n",
      "2 Roberto Cherro Boca Junio\n",
      "3 Alberto Chividini Central Norte TucumÃ\n",
      "4  Club Atletico Estudiantil PorteÃ±o\n",
      "5  Racing Club de Avellaneda\n",
      "6 Juan Evaristo Sportivo Barrac\n",
      "7 Mario Evaristo Boca Junio\n",
      "8 Manuel Ferreira Estudiantes de La Pla\n",
      "9 Luis Monti Club AtlÃ©tico San Lorenzo de Almagro\n"
     ]
    }
   ],
   "source": [
    "for i,j in enumerate(_json):\n",
    "    if(i<10):\n",
    "        print i,j['FullName'],j['Club']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "format()을 사용하여 출력형식을 정의할 수 있다.\n",
    "{}안에 순서, 출력자리수를 정의한다.\n",
    "2d는 숫자 2자리, 20s는 문자 20자리를 의미한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " 0 name:Ãngel Bossio         club:Club AtlÃ©tico Talleres de Remedios de Escalada\n",
      " 1 name:Juan Botasso         club:Quilmes AtlÃ©tico Club\n",
      " 2 name:Roberto Cherro       club:Boca Junio\n",
      " 3 name:Alberto Chividini    club:Central Norte TucumÃ\n",
      " 4 name:                     club:Club Atletico Estudiantil PorteÃ±o\n",
      " 5 name:                     club:Racing Club de Avellaneda\n",
      " 6 name:Juan Evaristo        club:Sportivo Barrac\n",
      " 7 name:Mario Evaristo       club:Boca Junio\n",
      " 8 name:Manuel Ferreira      club:Estudiantes de La Pla\n",
      " 9 name:Luis Monti           club:Club AtlÃ©tico San Lorenzo de Almagro\n",
      "10 name:                     club:Boca Junio\n",
      "11 name:Rodolfo Orlandini    club:Club Atletico Estudiantil PorteÃ±o\n",
      "12 name:Fernando Paternoster club:Racing Club de Avellaneda\n",
      "13 name:Natalio Perinetti    club:Racing Club de Avellaneda\n",
      "14 name:Carlos Peucelle      club:Club Sportivo Buenos Aires\n"
     ]
    }
   ],
   "source": [
    "for i,j in enumerate(_json):\n",
    "    if(i<15):\n",
    "        print u\"{0:2d} name:{1:20s} club:{2}\".format(i,j['FullName'],j['Club'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* 사례2\n",
    "    * New York State Baby Names, https://www.healthdata.gov/dataset/baby-names-beginning-2007"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "import requests\n",
    "_url=\"https://health.data.ny.gov/api/views/jxy9-yhdk/rows.json?accessType=DOWNLOAD\"\n",
    "r=requests.get(_url)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "_json=r.json()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* json데이터는 meta, data로 구분해서 만들어져 있슴\n",
    "* data는 52252건"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(_json)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[u'meta', u'data']"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "_json.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "_jsonList=_json['data']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "52252"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(_jsonList)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false,
    "scrolled": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, u'5DC7F285-052B-4739-8DC3-62827014A4CD', 1, 1425450997, u'714909', 1425450997, u'714909', u'{\\n}', u'2013', u'GAVIN', u'ST LAWRENCE', u'M', u'9']\n"
     ]
    }
   ],
   "source": [
    "print _json['data'][0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### S.3.3 csv 파일\n",
    "\n",
    "* csv파일은 데이터 항목을 쉼표로 분리한 파일 Comma Separated Values\n",
    "* 엑셀형식으로 이해할 수 있다.\n",
    "    * '줄'을 행\n",
    "    * '열'은 데이터 항목\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "collapsed": false,
    "scrolled": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "key1 key2 key3 value1 value1 value2\n",
      "c1 one a 82 1 2\n",
      "c1 one b 83 3 4\n",
      "c1 one c 97 5 6\n",
      "c2 one d 83 7 8\n",
      "c2 two a 78 9 10\n",
      "c2 two b 68 11 12\n",
      "c3 two c 38 13 14\n",
      "c3 two d 59 15 16\n",
      "c3 two d 55 15 16\n"
     ]
    }
   ],
   "source": [
    "import csv\n",
    " \n",
    "_file = open(\"data/jsldata2.csv\", \"rb\")\n",
    "reader = csv.reader(_file)\n",
    " \n",
    "rownum = 0\n",
    "for row in reader:\n",
    "    for col in row:\n",
    "        print '%s' % (col),\n",
    "    print\n",
    "_file.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "collapsed": false,
    "scrolled": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "key1 key2 key3 value1 value1 value2\n",
      "c1 one a 82 1 2\n",
      "c1 one b 83 3 4\n",
      "c1 one c 97 5 6\n",
      "c2 one d 83 7 8\n",
      "c2 two a 78 9 10\n",
      "c2 two b 68 11 12\n",
      "c3 two c 38 13 14\n",
      "c3 two d 59 15 16\n",
      "c3 two d 55 15 16\n"
     ]
    }
   ],
   "source": [
    "import csv\n",
    " \n",
    "_file = open(\"data/jsldata2.csv\", \"rb\")\n",
    "reader = csv.reader(_file)\n",
    " \n",
    "rownum = 0\n",
    "for row in reader:\n",
    "    for col in row:\n",
    "        print '%s' % (col),\n",
    "    print\n",
    "_file.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 문제 S-5: url에서 파일을 가져와 자료구조에 저장하기\n",
    "\n",
    "* uci 기계학습 데이터 파일 읽기\n",
    "* 로컬 파일을 읽는 것과 비교\n",
    "* 전체 문자 수는 25,437\n",
    "* 데이터는 300행 x 28열"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* urllib 또는 requests로 데이터를 가져올 수 있다. 그 길이는 25437로 당연히 동일하다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "25437\n"
     ]
    }
   ],
   "source": [
    "import urllib2\n",
    "url='http://archive.ics.uci.edu/ml/machine-learning-databases/horse-colic/horse-colic.data'\n",
    "\n",
    "res=urllib2.urlopen(url)\n",
    "html = res.read()\n",
    "res.close()\n",
    "print len(html)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "25437\n"
     ]
    }
   ],
   "source": [
    "import requests\n",
    "url='http://archive.ics.uci.edu/ml/machine-learning-databases/horse-colic/horse-colic.data'\n",
    "\n",
    "res=requests.get(url)\n",
    "html = res.text\n",
    "print len(html)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "리스트 자료로 저장한다.\n",
    "splitlines()는 줄바꿈 기호, line breaks '\\n'로 분리하여 리스트를 만든다.\n",
    "strip()은 줄바꿈을 제거하는 함수이다. splitlines()에서 제거되었으므로 사용하지 않아도 된다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "row:300 column:28\n",
      "[u'2', u'1', u'530101', u'38.50', u'66', u'28', u'3', u'3', u'?', u'2', u'5', u'4', u'4', u'?', u'?', u'?', u'3', u'5', u'45.00', u'8.40', u'?', u'?', u'2', u'2', u'11300', u'00000', u'00000', u'2']\n"
     ]
    }
   ],
   "source": [
    "lines=html.splitlines()\n",
    "data=[]\n",
    "for line in lines:\n",
    "    data.append(line.strip().split())\n",
    "print \"row:{} column:{}\".format(len(data), len(data[0]))\n",
    "print data[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 데이터 확인\n",
    "\n",
    "* 모든 300행에대해 28개 컬럼이 있는지\n",
    "* 처음 20개만 3번째 컬럼 평균내보기"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "for i in range(0,len(data)):\n",
    "    if len(data[i]) != len(data[0]):\n",
    "        print \"wrong size at\", i"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "38.50\n",
      "39.2\n",
      "38.30\n",
      "39.10\n",
      "37.30\n",
      "?\n",
      "37.90\n",
      "?\n",
      "?\n",
      "38.30\n",
      "38.10\n",
      "39.10\n",
      "37.20\n",
      "38.00\n",
      "38.2\n",
      "37.60\n",
      "?\n",
      "37.50\n",
      "37.60\n",
      "39.4\n"
     ]
    }
   ],
   "source": [
    "for i in range(0,20):\n",
    "    print data[i][3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 데이터를 처리할 경우 결측 값, missing value를 주의해야 한다.\n",
    "* 위에서 보듯이 결측 값이 '?'로 표시되었다.\n",
    "* SPSS, SAS 등 통계패키지를 사용하면 결측 값을 제외하는 기능을 손 쉽게 사용할 수 있지만 프로그래밍은 코드에 넣어주어야 한다.\n",
    "* 연산을 할 경우 형변환을 해야 한다. 파일문자는 연산을 할 수 없다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 38.50 38.5\n",
      "1 39.2 77.7\n",
      "2 38.30 116.0\n",
      "3 39.10 155.1\n",
      "4 37.30 192.4\n",
      "5 None\n",
      "6 37.90 230.3\n",
      "7 None\n",
      "8 None\n",
      "9 38.30 268.6\n",
      "10 38.10 306.7\n",
      "11 39.10 345.8\n",
      "12 37.20 383.0\n",
      "13 38.00 421.0\n",
      "14 38.2 459.2\n",
      "15 37.60 496.8\n",
      "16 None\n",
      "17 37.50 534.3\n",
      "18 37.60 571.9\n",
      "19 39.4 611.3\n",
      "count=16 sum=611.3 average=38.21\n"
     ]
    }
   ],
   "source": [
    "sum=0\n",
    "cnt=0\n",
    "for i in range(0,20):\n",
    "    val=data[i][3]\n",
    "    if val is '?':\n",
    "        print i,\"None\"\n",
    "    else:\n",
    "        sum+=float(val)\n",
    "        cnt+=1\n",
    "        print i,val, sum\n",
    "average=float(sum/cnt)\n",
    "print \"count={0} sum={1} average={2:2.2f}\".format(cnt,sum,average)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## S.4 MongoDB\n",
    "\n",
    "현재 많이 사용되는 관계형데이터베이스 (RDB, Relational Data Base)는 모델을 미리 정해야 하는 반면,\n",
    "MongoDB는 그렇지 않다.\n",
    "MongoDB는 데이터모델을 미리 정의하지 않고 저장하며, 모델이 없다는 의미로 schema free라고 한다.\n",
    "데이터를 읽어올 경우에도 Sql을 사용하지 않는다.\n",
    "그런 까닭에 NoSql이라고 말하기도 한다.\n",
    "\n",
    "MongoDB는 JSON문서를 그대로 저장하는 데이터베이스이다.\n",
    "MongoDB는 '문서'를 저장한다. 문서는 key-value로 구성된 JSON을 말한다.\n",
    "수, 문자, 객체와 같은 데이터 타잎을 사용할 수 있다.\n",
    "\n",
    "```\n",
    "{ \"id\": \"405\", \"name\": \"js\" }\n",
    "```\n",
    "\n",
    "텍스트, XML, HTML을 저장하려면 JSON으로 변환하여 저장해야 한다.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* MongoDB에는 컬럼과 레코드로 구성된 테이블 개념이 없다. 비슷한 개념은:\n",
    "    * Database - mongo는 데이터베이스를 생성하는 명령어가 없다. MongoDB는 BSON으로 저장\n",
    "    * Collections (RDB table)\n",
    "    * Document (RDB record)\n",
    "\n",
    "관계형 데이터베이스 | MongoDB\n",
    "-------|-------\n",
    "Database | Database\n",
    "Table | Collection\n",
    "Row | Document\n",
    "primary key | primary key (_id를 기본으로 제공)\n",
    "foreign key | foreign key 지원하지 않음.\n",
    "schema | schema free\n",
    "sql query | JSON query"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### S.4.1 설치\n",
    "\n",
    "* linux 설치\n",
    "```\n",
    "sudo apt-get install mongodb-org\n",
    "sudo pip install pymongo\n",
    "```\n",
    "\n",
    "* 윈도우 설치\n",
    "    * MongoDB 다운로드 센터 https://www.mongodb.com/download-center\n",
    "    * 자신의 컴퓨터에 해당하는 32,64비트 선택, 다운로드 msi 설치\n",
    "    * 윈도우 설치 오류\n",
    "        * C 컴파일러 버전 오류 \"api-ms-win=crt-runtime-l1-1-0.dll\"는 dll 검색해서 설치 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* config 설정\n",
    "    * 리눅스 /etc/mongodb.conf\n",
    "    * 윈도우 mongodb/conf 디렉토리 아래 설정파일\n",
    "    * 설정은 YAML 또는 init 형식으로 한다.\n",
    "    * 예:\n",
    "```\n",
    "fork = true\n",
    "bind_ip = 127.0.0.1\n",
    "port = 27017\n",
    "quiet = true\n",
    "dbpath = /var/lib/mongodb\n",
    "logpath = /var/log/mongodb/mongod.log\n",
    "logappend = true\n",
    "journal = true\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* DB 저장 디렉토리 설정변경\n",
    "    * 설정 파일 '/etc/mongodb.conf' 에서 변경할 수 있다. 기본 디렉토리는 '/data/db' 현재 설정은:\n",
    "```\n",
    "dbpath=/var/lib/mongodb\n",
    "```\n",
    "        \n",
    "    * cli로 변경할 수 있다. 현재 서버 mongod가 실행되고 있다면, 서버를 중지하고 난 후 실행하도록 한다.\n",
    "```\n",
    "mongod --dbpath mymongodb\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* 서버 실행: 'mongod' 서버 (서버를 실행하면서 config 및 db경로를 설정한다)\n",
    "    * 리눅스 cli (osx도 동일하게 실행한다):\n",
    "```\n",
    "mongod --config ./mongodb.conf --dbpath ./data --port 27017\n",
    "```\n",
    "\n",
    "    * daemon으로 실행할 경우:\n",
    "```\n",
    "sudo service mongodb start\n",
    "sudo service mongodb stop\n",
    "```\n",
    "\n",
    "    * 윈도우 cli:\n",
    "        * 경로를 설정한다. cli로 할 수 있다 (제어판에서 하는 것이 쉽다)\n",
    "```\n",
    "setx mongodb \"C:\\Program Files\\MongdDB\\Server\\3.2\"\n",
    "setx path \"%path%\";\"%mongodb%\\bin\"\n",
    "mongod\n",
    "```\n",
    "\n",
    "        * 32비트 설치 후 실행하는 경우, storageEngine오류 발생. 오류메시지 읽어보고 따라 함.\n",
    "```\n",
    "mongod --storageEngine=mmapv1 --dbpath [your-path]\n",
    "```\n",
    "\n",
    "    * 문제가 있으면 위 명령문에 --repair 붙여서 한 후, --repair 빼고 다시 실행"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* 클라이언트 실행: 'mongo'\n",
    "\n",
    "```\n",
    "mongo\n",
    "또는\n",
    "mongo -u new_user -p new_password new_database\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* 오류\n",
    "    * 'Failed to connect to 127.0.0.1:27017' 서버를 실행하지 않고 하는 경우 발생한다.\n",
    "    * 'port already in use' 사용하는 port를 해제한다.\n",
    "        * netstat -nlp | grep 하거나 lsof -i tcp:27017\n",
    "```\n",
    "$ ps -ax | grep mongo\n",
    "$ kill -9 15302\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### S.4.2 MongoDB shell\n",
    "\n",
    "* sample cli\n",
    "```\n",
    "$ mongo\n",
    "> show dbs\n",
    "> use test\n",
    "> db.createCollection(\"myCollection\")\n",
    "> show collections\n",
    "> db.getCollectionNames() or show collections or show tables\n",
    "> db.dropDatabase()\n",
    "> db.help()\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* mongofiles cli\n",
    "    * GridFS 파일시스템을 사용하는 명령어\n",
    "    * GridFS는 동영상, 오디오와 같이 큰 파일을 저장하고, 읽을 경우 사용한다.\n",
    "\n",
    "```\n",
    "mongofiles list\n",
    "```\n",
    "\n",
    "* help는 --help"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* cli 명령어\n",
    "\n",
    "\n",
    "구분 | 예 | 설명\n",
    "-------|-------\n",
    "Database create | > use mydb | mydb 없으면 생성, 존재하면 사용한다.\n",
    "Database delete | > use mydb <br> > db.dropDatabase() | mydb를 삭제함\n",
    "Collection create | > db.mycollection.insert( {\"name\":\"js\"} ) | 또는 'save()'를 사용. mycollection 없으면 생성, 존재하면 입력.\n",
    "Collection create | > db.createCollection(mycollection, options) | mycollection 생성. options는 선택.\n",
    "Collection insert | > db.mydb.insert_one( {\"name\":\"js\"} ) | ??insertOne() insertMany()\n",
    "Collection drop | > db.mycollection.drop() | mycollection을 삭제\n",
    "Collection read | > db.mycollection.find() | 데이터 검색 limit(), sort()\n",
    "Collection read | > db.mycollection.find({\"likes\":{$lt:50}}) | 조건 검색 (less than)\n",
    "Collection update | > db.mycollection.update_one( {'name':'js 1'} ) | 갱신\n",
    "Collection remove | > db.mycollection.remove() | 삭제 1건\n",
    "Collection remove | > db.mycollection.remove( {'name':'js' } ) | 조건 삭제"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* admin\n",
    "\n",
    "예 | 설명\n",
    "-------|-------\n",
    "show dbs | show dbs show db list\n",
    "show collections | show collection list\n",
    "db.seoul.count() | record 갯수"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* mongo client로 접속하면 'test' Database에 연결된다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "scrolled": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MongoDB shell version: 2.6.10\n",
      "connecting to: test\n",
      "> "
     ]
    }
   ],
   "source": [
    "!mongo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Writing src/ds_save_mongo_test.js\n"
     ]
    }
   ],
   "source": [
    "%%writefile src/ds_save_mongo_test.js\n",
    "use test\n",
    "db.testCollection.insert({x:1})\n",
    "db.testCollection.find()\n",
    "db.stats()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MongoDB shell version: 2.6.10\r\n",
      "connecting to: test\r\n",
      "switched to db test\r\n",
      "WriteResult({ \"nInserted\" : 1 })\r\n",
      "{ \"_id\" : ObjectId(\"58e73d5a6420d435d5308886\"), \"x\" : 1 }\r\n",
      "{\r\n",
      "\t\"db\" : \"test\",\r\n",
      "\t\"collections\" : 8,\r\n",
      "\t\"objects\" : 54,\r\n",
      "\t\"avgObjSize\" : 89.48148148148148,\r\n",
      "\t\"dataSize\" : 4832,\r\n",
      "\t\"storageSize\" : 65536,\r\n",
      "\t\"numExtents\" : 8,\r\n",
      "\t\"indexes\" : 8,\r\n",
      "\t\"indexSize\" : 65408,\r\n",
      "\t\"fileSize\" : 67108864,\r\n",
      "\t\"nsSizeMB\" : 16,\r\n",
      "\t\"dataFileVersion\" : {\r\n",
      "\t\t\"major\" : 4,\r\n",
      "\t\t\"minor\" : 5\r\n",
      "\t},\r\n",
      "\t\"extentFreeList\" : {\r\n",
      "\t\t\"num\" : 4,\r\n",
      "\t\t\"totalSize\" : 278528\r\n",
      "\t},\r\n",
      "\t\"ok\" : 1\r\n",
      "}\r\n",
      "bye\r\n"
     ]
    }
   ],
   "source": [
    "!mongo < src/ds_save_mongo_test.js"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 문제 S-6: MongDB에 'id', '이름'을 저장하고, 조회하는 프로그램을 실행하기\n",
    "\n",
    "* javascript 파일 'src/ds_save_mongo_5.js'을 작성하고 실행한다.\n",
    "* Database명 'myDB'\n",
    "* Collection명 'myCol'\n",
    "* 데이터\n",
    "```\n",
    "Persons:\n",
    "    id:405, 이름:js1\n",
    "    id:406, 이름:js2\n",
    "```\n",
    "* 이름이 js1인 경우 조회"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Writing src/ds_save_mongo_5.js\n"
     ]
    }
   ],
   "source": [
    "%%writefile src/ds_save_mongo_5.js\n",
    "use myDB\n",
    "show dbs\n",
    "show tables\n",
    "db.myCol.insert({\"Persons\":[{\"id\":\"405\", \"이름\":\"js1\"},{\"id\":\"406\", \"이름\":\"js2\"}]})\n",
    "db.myCol.find({ \"Persons.이름\": \"js1\" })"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MongoDB shell version: 2.6.10\n",
      "connecting to: test\n",
      "switched to db myDB\n",
      "Employees                   0.078GB\n",
      "_tweet_db                   0.078GB\n",
      "admin                       (empty)\n",
      "ds_rest_subwayPassengersDb  0.078GB\n",
      "ds_twitter                  0.078GB\n",
      "ieee                        0.078GB\n",
      "local                       0.078GB\n",
      "myDB                        0.078GB\n",
      "test                        0.078GB\n",
      "system.indexes\n",
      "WriteResult({ \"nInserted\" : 1 })\n",
      "{ \"_id\" : ObjectId(\"58e740680788ecb61aab86c3\"), \"Persons\" : [ { \"id\" : \"405\", \"이름\" : \"js1\" }, { \"id\" : \"406\", \"이름\" : \"js2\" } ] }\n",
      "bye\n"
     ]
    }
   ],
   "source": [
    "!mongo < src/ds_save_mongo_5.js"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### S.4.3 pymongo\n",
    "\n",
    "* 설치\n",
    "    * 리눅스 pip install pymongo\n",
    "    * 윈도우\n",
    "```\n",
    "conda install pymongo\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "* 실행\n",
    "    * mongod가 백그라운드에서 실행되고 있어야 한다 (대기 상태 실행)\n",
    "    * 아래 문제와 같이 pymongo 세션을 시작하면, 백그라운드 mongod가 \"connection accpeted from localhost...\"\n",
    "    * connection은 close할 수 있다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "* client는 conf 파일을 읽어서 설정한다. 'localhost:27017'는 생략할 수 있다.\n",
    "```\n",
    "client = MongoClient('localhost:27017')\n",
    "```\n",
    "\n",
    "* dictionary 스타일로 database를 사용할 수 있다.\n",
    "```\n",
    "client['myDB']\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "import pymongo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "client = pymongo.MongoClient()\n",
    "db=client.myDB"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* insert"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "_id=1\n",
    "_name='js'\n",
    "_age=11\n",
    "_country='ko'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* 입력은 insert_one(), insert_many()를 사용한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false,
    "scrolled": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<pymongo.results.InsertOneResult at 0x7f3102134320>"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "db.myPyCol.insert_one({\n",
    "    \"id\": _id,\n",
    "    \"name\": _name,\n",
    "    \"age\": _age,\n",
    "    \"country\": _country\n",
    "})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* find()함수는 pymongo.cursor.Cursor 객체를 반환하고, key로 결과를 조회할 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false,
    "scrolled": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "js\n"
     ]
    }
   ],
   "source": [
    "results = db.myPyCol.find()\n",
    "for r in results:\n",
    "        print r['name']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* update"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<pymongo.results.UpdateResult at 0x7f3102134460>"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "_name='jslim'\n",
    "_age=123\n",
    "db.myPyCol.update_one(\n",
    "        {\"id\": _id},\n",
    "        {\n",
    "            \"$set\": {\n",
    "                \"name\":_name,\n",
    "                \"age\":_age,\n",
    "            }\n",
    "        }\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false,
    "scrolled": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 jslim\n"
     ]
    }
   ],
   "source": [
    "results = db.myPyCol.find()\n",
    "for r in results:\n",
    "        print r['id'],r['name']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* delete\n",
    "* 실행 후, 삭제되었는지 MongoDB shell로 확인한다.\n",
    "```\n",
    "> db.myPyCol.find()\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<pymongo.results.DeleteResult at 0x7f31021630f0>"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "db.myPyCol.delete_many({\"id\":1})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 문제 S-7: Python으로 MongoDB Persons 조회하기\n",
    "\n",
    "* S-5의 Persons 데이터를 조회한다.\n",
    "* Database명 'myDB'\n",
    "* Collection명 'myCol'\n",
    "* 데이터\n",
    "```\n",
    "Persons:\n",
    "    id:405, 이름:js1\n",
    "    id:406, 이름:js2\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[{u'\\uc774\\ub984': u'js1', u'id': u'405'}, {u'\\uc774\\ub984': u'js2', u'id': u'406'}]\n"
     ]
    }
   ],
   "source": [
    "import pymongo\n",
    "\n",
    "client = pymongo.MongoClient('localhost:27017')\n",
    "db=client.myDB\n",
    "results = db.myCol.find()\n",
    "for r in results:\n",
    "        print r['Persons']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## 문제 S-8: 음악 검색결과를 MongoDB 저장\n",
    "\n",
    "앞 장에서 스크레이핑을 하고 그 결과를 화면에 출력하였다.\n",
    "여기서는 그 결과를 파일에 저장한다.\n",
    "다음에는 저장한 결과를 분석하게 된다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "import pymongo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "client = pymongo.MongoClient('localhost:27017')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "db=client.myMusicDB\n",
    "_artist='자두'\n",
    "_name='비오는'\n",
    "_album='비오는앨범'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<pymongo.results.InsertOneResult at 0x7f31021631e0>"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "db.myMusicCol.insert_one({\n",
    "    \"id\": _artist,\n",
    "    \"name\": _name,\n",
    "    \"album\": _album,\n",
    "})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "```\n",
    "> use myMusicDB\n",
    "switched to db myMusicDB\n",
    "> show tables\n",
    "myMusicCol\n",
    "system.indexes\n",
    "> db.myMusicCol.find()\n",
    "{ \"_id\" : ObjectId(\"59f4085df5e6e94a21f2abef\"), \"age\" : \"비오는앨범\", \"id\" : \"자두\", \"name\" : \"비오는\" }\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting src/ds5_8_naverMusicSaveDB.py\n"
     ]
    }
   ],
   "source": [
    "%%writefile src/ds5_8_naverMusicSaveDB.py\n",
    "#!\n",
    "# encoding:utf-8\n",
    "import pymongo\n",
    "\n",
    "client = pymongo.MongoClient('localhost:27017')\n",
    "\n",
    "db=client.myMusicDB\n",
    "\n",
    "\n",
    "import requests\n",
    "from bs4 import BeautifulSoup\n",
    "\n",
    "pageNo=1\n",
    "p = {\"query\": u\"비오는\",\"target\":\"track\", \"page\":pageNo}\n",
    "naverUrl=\"http://music.naver.com/search/search.nhn?\"\n",
    "\n",
    "def saveMusicBS():\n",
    "    try:\n",
    "        #fout=open('ds5_1_naverMusicSave.txt','w')\n",
    "        for pageNo in range(2):\n",
    "            p = {\"query\": u\"비오는\",\"target\":\"track\", \"page\":pageNo}\n",
    "            r = requests.get(naverUrl,params=p)\n",
    "            soup=BeautifulSoup(r.text,\"lxml\")\n",
    "            _selName = [title.get_text().strip() for title in soup.select('._tracklist_move > .name > a.title')]\n",
    "            _selArtist = [artist.get_text().strip() for artist in soup.select('._artist.artist')]\n",
    "            _selAlbum= [album.get_text().strip() for album in soup.select('.album > a')]\n",
    "            print \"total number of items:\",len(_selName)\n",
    "            for i in range(len(_selName)):\n",
    "                row=u\"{0}\\t{1}\\t{2}\\t{3}\\n\".format(pageNo,_selArtist[i],_selName[i],_selAlbum[i])\n",
    "                db.myMusicCol.insert_one({\n",
    "                    \"id\": _selArtist[i],\n",
    "                    \"name\": _selName[i],\n",
    "                    \"album\": _selAlbum[i],\n",
    "                })\n",
    "                #fout.write(row.encode('utf-8'))\n",
    "                print row\n",
    "        #fout.close()\n",
    "    except requests.exceptions.HTTPError as e:\n",
    "        print e\n",
    "        sys.exit(1)\n",
    "\n",
    "def main():\n",
    "    saveMusicBS()\n",
    "\n",
    "if __name__==\"__main__\":\n",
    "    main()\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## S.5 CouchDB\n",
    "\n",
    "* Apache 오픈소스 데이터베이스\n",
    "* NoSql 데이터베이스이다.\n",
    "* json을 저장"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### S.5.1 설치\n",
    "\n",
    "* http://couchdb.apache.org로 가서 설치파일을 내려받아 설치할 수 있다.\n",
    "* 리눅스에서는 apt를 사용하여 설치할 수 있다. 최신 버전이 아닐 수 있다.\n",
    "```\n",
    "sudo apt-get install couchdb\n",
    "```\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* 서버의 실행\n",
    "    * '/etc/init.d/couchdb'를 사용해 start, stop할 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[0;1;32m●\u001b[0m couchdb.service - System-wide CouchDB instance\n",
      "   Loaded: loaded (/lib/systemd/system/couchdb.service; enabled; vendor preset: enabled)\n",
      "   Active: \u001b[0;1;32mactive (running)\u001b[0m since 화 2017-03-28 11:47:56 KST; 2 days ago\n",
      " Main PID: 1408 (beam.smp)\n",
      "   CGroup: /system.slice/couchdb.service\n",
      "           ├─1408 /usr/lib/erlang/erts-7.3/bin/beam.smp -Bd -K true -A 4 -- -...\n",
      "           └─1645 sh -s disksup\n",
      "\n",
      " 3월 28 11:48:04 jsl-smu couchdb[1408]: File operation error: eacces. Targe....\n",
      " 3월 28 11:48:04 jsl-smu couchdb[1408]: =ERROR REPORT==== 28-Mar-2017::20:4...=\n",
      " 3월 28 11:48:04 jsl-smu couchdb[1408]: File operation error: eacces. Targe....\n",
      " 3월 28 11:48:09 jsl-smu couchdb[1408]: Apache CouchDB 1.6.0 (LogLevel=info....\n",
      " 3월 28 11:48:10 jsl-smu couchdb[1408]: Apache CouchDB has started. Time to....\n",
      " 3월 28 11:48:10 jsl-smu couchdb[1408]: [info] [<0.33.0>] Apache CouchDB ha.../\n",
      " 3월 31 06:29:34 jsl-smu couchdb[1408]: [info] [<0.100.0>] 127.0.0.1 - - PU...5\n",
      " 3월 31 06:29:52 jsl-smu couchdb[1408]: [info] [<0.17729.7>] 127.0.0.1 - - ...0\n",
      " 3월 31 06:30:09 jsl-smu couchdb[1408]: [info] [<0.17750.7>] 127.0.0.1 - - ...0\n",
      " 3월 31 06:34:55 jsl-smu couchdb[1408]: [info] [<0.104.0>] 127.0.0.1 - - GE...0\n",
      "Hint: Some lines were ellipsized, use -l to show in full.\n"
     ]
    }
   ],
   "source": [
    "!/etc/init.d/couchdb status"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* 설치 확인\n",
    "    * 웹브라우저 http://127.0.0.1:5984/\n",
    "    * 명령창\n",
    "```\n",
    "$ curl http://localhost:5984\n",
    "```\n",
    "\n",
    "* fution: CouchDB의 웹인터페이스\n",
    "```\n",
    "http://127.0.0.1:5984/_utils/\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false,
    "scrolled": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\"couchdb\":\"Welcome\",\"uuid\":\"a7461e0dccf40fd1e03a8d8f48bebcda\",\"version\":\"1.6.0\",\"vendor\":{\"name\":\"Ubuntu\",\"version\":\"15.10\"}}\r\n"
     ]
    }
   ],
   "source": [
    "!curl http://localhost:5984"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* 설정\n",
    "    * 원격 접근을 하려면 설정을 변경해야 한다.\n",
    "        * 로컬 127.0.0.1에서 사용하도록 설정되어 있다.\n",
    "        * /etc/couchdb/아래의 ini파일을 변경한다 (default.ini, local.ini어는 것을 변경해도 된다.)\n",
    "```\n",
    "[httpd]\n",
    "port = 5984\n",
    "bind_address = 0.0.0.0\n",
    "```\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### S.5.2 cURL\n",
    "\n",
    "flags | 설명\n",
    "-----|-----\n",
    "X | http request 함수를 설정할 경우 사용한다. GET은 생략할 수 있다.\n",
    "H | header 정보를 설정할 경우 사용한다.\n",
    "d | http POST를 사용하여, 데이터를 전송할 경우 사용한다.\n",
    "o | 결과를 파일에 쓸 경우 사용한다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* 변수를 저장해서 사용할 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "host='http://127.0.0.1:5984'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\"couchdb\":\"Welcome\",\"uuid\":\"a7461e0dccf40fd1e03a8d8f48bebcda\",\"version\":\"1.6.0\",\"vendor\":{\"name\":\"Ubuntu\",\"version\":\"15.10\"}}\r\n"
     ]
    }
   ],
   "source": [
    "!curl {host}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* 데이터베이스 목록 출력하기"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[\"_replicator\",\"_users\",\"mydb\"]\r\n"
     ]
    }
   ],
   "source": [
    "!curl -X GET http://127.0.0.1:5984/_all_dbs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### S.5.3 데이터베이스\n",
    "\n",
    "기능 | 예\n",
    "-----|-----\n",
    "데이터베이스 생성 | curl -X PUT http://127.0.0.1:5984/mytest\n",
    "조회\t| curl http://127.0.0.1:5984/mytest\n",
    "삭제 | curl -X DELETE http://127.0.0.1:5984/mytest\n",
    "문서 생성 | curl -X POST -H \"Content-Type: application/json\" --data '{ \"id\" : \"405\", \"name\": \"js\" } 'http://127.0.0.1:5984/mytest"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* 데이터베이스 생성"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "host='http://127.0.0.1:5984'\n",
    "dbname='mydb'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\"ok\":true}\r\n"
     ]
    }
   ],
   "source": [
    "!curl -X PUT {host}/{dbname}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* 데이터베이스 조회"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\"db_name\":\"mydb\",\"doc_count\":1,\"doc_del_count\":0,\"update_seq\":5,\"purge_seq\":0,\"compact_running\":false,\"disk_size\":20578,\"data_size\":636,\"instance_start_time\":\"1491001015142484\",\"disk_format_version\":6,\"committed_update_seq\":5}\r\n"
     ]
    }
   ],
   "source": [
    "!curl {host}/{dbname}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* 데이터베이스 삭제"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\"ok\":true}\r\n"
     ]
    }
   ],
   "source": [
    "!curl -X DELETE http://127.0.0.1:5984/{dbname}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### 문제 S-8: CouchDB로 html 페이지 저장하기\n",
    "\n",
    "* 문서 저장\n",
    "    * 'mypage1.html'을 저장하기\n",
    "    * '--data-binary'를 사용할 수 있다. '@'는 파일을 첨부할 경우 사용한다.\n",
    "    * 또는 '-d'를 사용할 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "docname='webpage'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\"error\":\"conflict\",\"reason\":\"Document update conflict.\"}\r\n"
     ]
    }
   ],
   "source": [
    "!curl -X PUT {host}/{dbname}/{docname}/mypage4.html --data-binary @mypage1.html -H \"Content-Type: text/html\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* 문서 조회"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\"total_rows\":2,\"offset\":0,\"rows\":[\r",
      "\r\n",
      "{\"id\":\"_design/example\",\"key\":\"_design/example\",\"value\":{\"rev\":\"1-230141dfa7e07c3dbfef0789bf11773a\"}},\r",
      "\r\n",
      "{\"id\":\"webpage\",\"key\":\"webpage\",\"value\":{\"rev\":\"8-73f2eb26728b6664161a9d3137056663\"}}\r",
      "\r\n",
      "]}\r\n"
     ]
    }
   ],
   "source": [
    "!curl -X GET http://127.0.0.1:5984/mydb/_all_docs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\"_id\":\"webpage\",\"_rev\":\"7-aaca1213cef074aff492232a71f3faa5\",\"_attachments\":{\"mypage1.html\":{\"content_type\":\"application/x-www-form-urlencoded\",\"revpos\":1,\"digest\":\"md5-bZ4eW97EQcd/NFs0+kTFwg==\",\"length\":197,\"stub\":true}}}\r\n"
     ]
    }
   ],
   "source": [
    "!curl -X GET {host}/{dbname}/{docname}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false,
    "scrolled": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<!DOCTYPE html>\r\n",
      "<html>\r\n",
      "<head>\r\n",
      "<title>My Home Page</title>\r\n",
      "</head>\r\n",
      "<body>\r\n",
      "<h1>안녕하십니까</h1>\r\n",
      "<p>오늘은 프로그래밍 하는 날...</p>\r\n",
      "<p>Today we do programming...</p>\r\n",
      "</body>\r\n",
      "</html>"
     ]
    }
   ],
   "source": [
    "!curl -X GET {host}/{dbname}/{docname}/mypage1.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* 문서 삭제\n",
    "    * '_id?rev=_rev'로 삭제할 수 있다.\n",
    "    * '_id'와 '_rev'는 조회해서 확인한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\"ok\":true,\"id\":\"webpage\",\"rev\":\"8-73f2eb26728b6664161a9d3137056663\"}\r\n"
     ]
    }
   ],
   "source": [
    "!curl -X DELETE {host}/{dbname}/{docname}/webpage?rev=7-aaca1213cef074aff492232a71f3faa5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\"error\":\"bad_request\",\"reason\":\"Document must be a JSON object\"}\r\n"
     ]
    }
   ],
   "source": [
    "!curl -X PUT {host}/{dbname}/{docname} -H 'Content-Type: application/json' -d @ds_web_data_kospi200.json"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "a={\"id\": \"405\"}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "curl: (6) Could not resolve host: host\r\n"
     ]
    }
   ],
   "source": [
    "!curl -X POST {host}/{dbname} -H \"Content-Type: application/json\" -d '{\"id\": \"405\"}'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### S.5.4 View\n",
    "\n",
    "* 문서에 대해 map-reduce 등의 처리 기능을 실행\n",
    "* permanent, temporary views 기능\n",
    "\n",
    "```\n",
    "# curl -H \"Content-type: application/json\"\\\n",
    "#     -X POST $host/$dbname\\\n",
    "#     -d \"{\n",
    "#     \\\"firstname\\\" : \\\"Martin\\\",\n",
    "#     \\\"address\\\" : {\n",
    "#             \\\"home\\\" : [\n",
    "#                 \\\"Some road\\\",\n",
    "#                 \\\"Some town\\\",\n",
    "#                 \\\"Postcode\\\",\n",
    "#                 \\\"Country\\\"\n",
    "#             ]\n",
    "#         },\n",
    "#         \\\"title\\\" : \\\"Mr\\\",\n",
    "#         \\\"lastname\\\" : \\\"Brown\\\",\n",
    "#         \\\"phones\\\" : {\n",
    "#             \\\"home\\\" : \\\"09874978\\\",\n",
    "#             \\\"mobile\\\" : \\\"0892374908\\\"\n",
    "#         }\n",
    "#     }\"\n",
    "# curl -X GET http://127.0.0.1:5984\n",
    "    /mydb/_design/example/_view/viewjsl\n",
    "    /mydb/_design/example/_view/viewjsl?group=true\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* permanent views\n",
    "    * URI /{dbname}/{docid}/{viewname}\n",
    "    * {docid} has the prefix _design/\n",
    "    * {viewname} has the prefix _view"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting mydesign.json\n"
     ]
    }
   ],
   "source": [
    "%%writefile mydesign.json\n",
    "{\n",
    "  \"_id\" : \"_design/example\",\n",
    "  \"views\" : {\n",
    "    \"foo\" : {\n",
    "      \"map\" : \"function(doc){ emit(doc._id, doc._rev)}\"\n",
    "    }\n",
    "  }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\"ok\":true,\"id\":\"_design/example\",\"rev\":\"3-5dac715cb734d6331128995ab3094fb7\"}\r\n"
     ]
    }
   ],
   "source": [
    "!curl -X PUT http://127.0.0.1:5984/mydb/_design/example --data-binary @mydesign.json"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* 조회\n",
    "    * id로 설정한 값으로 생성"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\"total_rows\":4,\"offset\":0,\"rows\":[\r",
      "\r\n",
      "{\"id\":\"_design/example\",\"key\":\"_design/example\",\"value\":{\"rev\":\"3-5dac715cb734d6331128995ab3094fb7\"}},\r",
      "\r\n",
      "{\"id\":\"_design/testmyshow1\",\"key\":\"_design/testmyshow1\",\"value\":{\"rev\":\"1-90ae5096a64b292624ff6b98374209a0\"}},\r",
      "\r\n",
      "{\"id\":\"_design/testmyshow2\",\"key\":\"_design/testmyshow2\",\"value\":{\"rev\":\"1-25f1d246b18629889f2d1aca7baac2c6\"}},\r",
      "\r\n",
      "{\"id\":\"_design/testmyshow3\",\"key\":\"_design/testmyshow3\",\"value\":{\"rev\":\"1-2373f745c69bd72654522986a2033138\"}}\r",
      "\r\n",
      "]}\r\n"
     ]
    }
   ],
   "source": [
    "!curl -X GET http://127.0.0.1:5984/mydb/_all_docs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\"_id\":\"_design/example\",\"_rev\":\"3-5dac715cb734d6331128995ab3094fb7\",\"views\":{\"foo\":{\"map\":\"function(doc){ emit(doc._id, doc._rev)}\"}}}\r\n"
     ]
    }
   ],
   "source": [
    "!curl -X GET http://127.0.0.1:5984/mydb/_design/example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\"total_rows\":0,\"offset\":0,\"rows\":[\r",
      "\r\n",
      "\r",
      "\r\n",
      "]}\r\n"
     ]
    }
   ],
   "source": [
    "!curl -X GET http://127.0.0.1:5984/mydb/_design/example/_view/foo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* temporary views: not stored in the database, but rather executed on demand\n",
    "    * URI /{dbname}/_temp_view\n",
    "    * Content-Type header is set to application/json"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\"error\":\"not_found\",\"reason\":\"missing_named_view\"}\r\n"
     ]
    }
   ],
   "source": [
    "!curl -X POST http://127.0.0.1:5984/mydb/_temp_view -H \"Content-Type: application/json\" -d '{\"id\": \"405\"}'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "curl: (6) Could not resolve host: host\r\n"
     ]
    }
   ],
   "source": [
    "!curl -X POST {host}/{dbname}/_temp_view -H \"Content-Type: application/json\" -d '{\"map\": \"function(doc) { \\\n",
    "            if (doc.type==\"quote\") { \\\n",
    "                emit(doc.work.year,doc);\\\n",
    "            }\\\n",
    "        }\\\n",
    "    }'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### S.5.5 Shows\n",
    "\n",
    "* html문서를 생성하는 기능, 문서doc를 사용할 수 있다.\n",
    "```\n",
    "function(doc, req) {\n",
    "  return '<h1>' + doc.title + '</h1>';\n",
    "}\n",
    "```\n",
    "\n",
    "* design 내에 생성된다.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* 연습1\n",
    "    * doc을 인자로 사용한다. doc 인자로 넘겨주지 않으면 오류가 발생한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting myshow1.json\n"
     ]
    }
   ],
   "source": [
    "%%writefile myshow1.json\n",
    "{\n",
    "    \"shows\": {\n",
    "         \"recipe\" : \"function (doc,req) { return '<h1>' + doc.title + '</h1>'}\"\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\"ok\":true,\"id\":\"_design/testmyshow1\",\"rev\":\"1-90ae5096a64b292624ff6b98374209a0\"}\r\n"
     ]
    }
   ],
   "source": [
    "!curl -X PUT http://127.0.0.1:5984/mydb/_design/testmyshow1 --data-binary @myshow1.json"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\"total_rows\":1,\"offset\":0,\"rows\":[\r",
      "\r\n",
      "{\"id\":\"_design/testmyshow1\",\"key\":\"_design/testmyshow1\",\"value\":{\"rev\":\"1-90ae5096a64b292624ff6b98374209a0\"}}\r",
      "\r\n",
      "]}\r\n"
     ]
    }
   ],
   "source": [
    "!curl http://127.0.0.1:5984/mydb/_all_docs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* 연습 1의 삭제"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {
    "collapsed": false,
    "scrolled": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\"ok\":true,\"id\":\"webpage\",\"rev\":\"9-15a13d4279bdddd50900db99e7e7a8d6\"}\r\n"
     ]
    }
   ],
   "source": [
    "!curl -X DELETE {host}/{dbname}/_design/testmyshow1?rev=1-90ae5096a64b292624ff6b98374209a0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* 연습 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting myshow2.json\n"
     ]
    }
   ],
   "source": [
    "%%writefile myshow2.json\n",
    "{\n",
    "    \"shows\":{\n",
    "        \"myshow\": \"function(doc, req) {return '<p>Aye aye, ' + req.query.parrot + '!</p>';}\"\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\"ok\":true,\"id\":\"_design/testmyshow2\",\"rev\":\"1-25f1d246b18629889f2d1aca7baac2c6\"}\r\n"
     ]
    }
   ],
   "source": [
    "!curl -X PUT http://127.0.0.1:5984/mydb/_design/testmyshow2 --data-binary @myshow2.json"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<p>Aye aye, Captain!</p>"
     ]
    }
   ],
   "source": [
    "!curl http://127.0.0.1:5984/mydb/_design/testmyshow2/_show/myshow?parrot=Captain"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* id를 사용할 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<p>Aye aye, undefined!</p>"
     ]
    }
   ],
   "source": [
    "!curl http://127.0.0.1:5984/mydb/_design/testmyshow2/_show/myshow/1-25f1d246b18629889f2d1aca7baac2c6"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* 연습 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Writing myshow3.json\n"
     ]
    }
   ],
   "source": [
    "%%writefile myshow3.json\n",
    "{\n",
    "    \"shows\":{\n",
    "        \"hello\": \"function(doc, req) {return { body: 'Hellooo World'}}\",\n",
    "        \"test\": \"function(doc, req) {return {body: '<foo>'+doc.title+'</foo>',headers: {'Content-Type':'application/xml','X-My-Own-Header':'own headers'}}}\"\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\"ok\":true,\"id\":\"_design/testmyshow3\",\"rev\":\"1-2373f745c69bd72654522986a2033138\"}\r\n"
     ]
    }
   ],
   "source": [
    "!curl -X PUT http://127.0.0.1:5984/mydb/_design/testmyshow3 --data-binary @myshow3.json"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {
    "collapsed": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hellooo World"
     ]
    }
   ],
   "source": [
    "!curl http://127.0.0.1:5984/mydb/_design/testmyshow3/_show/hello"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### S.5.6 Replication\n",
    "\n",
    "* CouchDB의 특별한 기능\n",
    "* 데이터베이스 동기화\n",
    "    * 소스의 데이터변경을 타켓에 동기화"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "curl -X POST http://localhost:5984/_replicate\\\n",
    "     -H \"Content-Type: application/json\" \\\n",
    "     -d '{\n",
    "        \"source\":\"http://117.16.47.18:5984/tweets-user-timeline-228329122\",\n",
    "        \"target\":\"http://localhost:5984/jsl\"\n",
    "     }'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "curl -X POST http://localhost:5984/_replicate\\\n",
    "     -H \"Content-Type: application/json\" \\\n",
    "     -d '{\n",
    "        \"source\":\"http://117.16.47.18:5984/tweets-user-timeline-111162906\",\n",
    "        \"target\":\"http://localhost:5984/jsl\"\n",
    "     }'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}