function.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from __future__ import print_function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello, world!\n"
     ]
    }
   ],
   "source": [
    "def hello_world():\n",
    "    msg = 'hello, world!'\n",
    "    return msg\n",
    "\n",
    "greeting = hello_world()\n",
    "print(greeting)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 인자의 기본값"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "bon jour\n",
      "좋은 오후\n",
      "좋은 저녁\n",
      "좋은 밤\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "def greetings(hour, lang='kr', extra_msg=None):\n",
    "    # 시간값 확인\n",
    "    if hour < 0 or hour > 24:\n",
    "        return\n",
    "    \n",
    "    # 언어에 따라 메시지 설정\n",
    "    msgs = {'kr': [u'좋은', u'아침', u'오후', u'저녁', u'밤'],\n",
    "            'en': [u'Good', u'morning', u'afternoon', u'evening', \n",
    "                   u'night']}\n",
    "\n",
    "    # 별도로 설정된 메시지가 있으면, 해당 메시지 반영\n",
    "    if not extra_msg is None:\n",
    "        for key, value in extra_msg.items():\n",
    "            msgs[key] = value\n",
    "    \n",
    "    # 해당 언어가 없으면 함수 종료\n",
    "    if not lang in msgs:\n",
    "        return\n",
    "    \n",
    "    msg_prefix = msgs[lang][0]\n",
    "    \n",
    "    # 시간에 따른 메시지 설정\n",
    "    msg = msg_prefix + ' '\n",
    "    if 6 < hour < 12:\n",
    "        msg += msgs[lang][1]\n",
    "    elif 12<= hour < 18:\n",
    "        msg += msgs[lang][2]\n",
    "    elif 18<= hour < 21:\n",
    "        msg += msgs[lang][3]\n",
    "    else:\n",
    "        msg += msgs[lang][4]\n",
    "    return msg\n",
    "\n",
    "print(greetings(9, lang='fr', \n",
    "                extra_msg={'fr': \n",
    "                           ['bon', \n",
    "                            'jour', 'soir', 'nuit']}))\n",
    "print(greetings(13))\n",
    "print(greetings(19))\n",
    "print(greetings(22))\n",
    "print(greetings(-2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Exit 1\n",
      "Exit 2\n",
      "그런 출구는 없습니다.\n"
     ]
    }
   ],
   "source": [
    "# return의 효과\n",
    "def many_exits(exit_no):\n",
    "    if exit_no==1:\n",
    "        return 'Exit 1'\n",
    "    if exit_no==2:\n",
    "        return 'Exit 2'\n",
    "    if exit_no==3:\n",
    "        return 'Exit 3'\n",
    "    \n",
    "    return '그런 출구는 없습니다.'\n",
    "\n",
    "print(many_exits(1))\n",
    "print(many_exits(2))\n",
    "print(many_exits(9))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 함수 인자\n",
    "\n",
    "함수의 인자를 학습하는 예시"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def juicer(ingredient, customer_name):\n",
    "    result = customer_name + u' 님, '\n",
    "\n",
    "    # TODO: 가능한 메뉴인지 확인\n",
    "    menu = [u'딸기', u'사과', u'망고']\n",
    "    if not ingredient in menu:\n",
    "        return None\n",
    "    \n",
    "    result += ingredient + u' 주스'\n",
    "    if ingredient == u'딸기':\n",
    "        price = 10\n",
    "    elif ingredient == u'사과':\n",
    "        price = 15\n",
    "    elif ingredient == u'망고':\n",
    "        price = 20\n",
    "   \n",
    "    return result, price"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "성주 님, 딸기 주스 나왔습니다.\n",
      "가격: 10\n"
     ]
    }
   ],
   "source": [
    "result = juicer(u'딸기', u'성주')\n",
    "if result is None:\n",
    "    print('그런 메뉴 없습니다.')\n",
    "else:\n",
    "    msg, price = result # 결과 튜플 언패킹\n",
    "    print(msg + u' 나왔습니다.')\n",
    "    print('가격: ' + str(price))\n",
    "# 출력 예시: 성주 님, 딸기 주스 나왔습니다.\n",
    "# 딸기 주스는 10원입니다.\n",
    "# 사과 주스는 15원입니다.\n",
    "# 망고 주스는 20원입니다."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "두 개 이상의 결과 반환(return)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2, 1)\n"
     ]
    }
   ],
   "source": [
    "def swap(x,y):\n",
    "    return (y,x)\n",
    "\n",
    "print(swap(1,2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 4\n",
      "<type 'tuple'>\n",
      "2 4\n"
     ]
    }
   ],
   "source": [
    "# 함수 정의\n",
    "def foo(a,b):\n",
    "    return a*2, b*2\n",
    "\n",
    "# 함수 호출\n",
    "aa, bb = foo(1,2)\n",
    "print(aa,bb)\n",
    "\n",
    "result = foo(1,2)\n",
    "print(type(result))\n",
    "print(result[0], result[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "인자에 미치는 효과"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "def double(x):\n",
    "    x = x*2\n",
    "    \n",
    "x = 1\n",
    "double(x)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4]\n",
      "[1, 4, 9, 16]\n"
     ]
    },
    {
     "ename": "TypeError",
     "evalue": "'tuple' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-80-8af4119b208f>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     18\u001b[0m \u001b[0;31m# list --> tuple\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     19\u001b[0m \u001b[0mnums\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mtuple\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnums\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 20\u001b[0;31m \u001b[0msquare_not_safe\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnums\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-80-8af4119b208f>\u001b[0m in \u001b[0;36msquare_not_safe\u001b[0;34m(seq)\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0msquare_not_safe\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mseq\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m     \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mn\u001b[0m \u001b[0;32min\u001b[0m \u001b[0menumerate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mseq\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m         \u001b[0mseq\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mseq\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m**\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      4\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0msquare_safe\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mseq\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "def square_not_safe(seq):\n",
    "    for i, n in enumerate(seq):\n",
    "        seq[i] = seq[i]**2\n",
    "\n",
    "def square_safe(seq):\n",
    "    # 값 복사\n",
    "    seq = list(seq[:])\n",
    "    for i, n in enumerate(seq):\n",
    "        seq[i] = seq[i]**2\n",
    "        \n",
    "    return seq\n",
    "\n",
    "nums = [1,2,3,4]\n",
    "result = square_safe(nums)\n",
    "print(nums)\n",
    "print(result)\n",
    "\n",
    "# list --> tuple\n",
    "nums = tuple(nums)\n",
    "square_not_safe(nums)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "함수의 스코프에서 선언된 변수는 지역변수"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'y' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-91-476778a57994>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0mfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 5\u001b[0;31m \u001b[0;32mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'y' is not defined"
     ]
    }
   ],
   "source": [
    "def func(x):\n",
    "    y = x\n",
    "    \n",
    "func(1)\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 제네레이터 (Generator)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def countdown(n):\n",
    "    print('카운트 다운 시작!')\n",
    "    while n>0:\n",
    "        yield n\n",
    "        n -=1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "c = countdown(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "카운트 다운 시작!\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c.next()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c.next()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "카운트 다운 시작!\n",
      "10 9 8 7 6 5 4 3 2 1 "
     ]
    }
   ],
   "source": [
    "for c in countdown(10):\n",
    "    print(c, end=' ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 도전과제\n",
    "\n",
    "리스트, 문자열과 같은 시퀀스를 받아서 홀수번째 원소만 선택해 반환하는 함수 its_odd를 정의하시오.\n",
    "\n",
    "예: \n",
    "\n",
    "    result = its_odd(u'파이썬')\n",
    "    print(result) # '파썬'\n",
    "    \n",
    "    result = its_odd([1,2,3,4,5])\n",
    "    print(result) # [1,3,5]\n",
    "    \n",
    "a. 입력과 출력을 다음 형식으로 파일 its_odd_result.txt에 저장하시오.\n",
    "\n",
    "파이썬 --> 파썬\n",
    "\n",
    "[1,2,3,4,5] --> [1,3,5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "파썬\n",
      "[1, 3, 5]\n"
     ]
    }
   ],
   "source": [
    "def its_odd(seq):\n",
    "    result = seq[::2]\n",
    "    return result\n",
    "\n",
    "result = its_odd(u'파이썬')\n",
    "print(result)\n",
    "\n",
    "print(its_odd([1,2,3,4,5]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "function"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(its_odd)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 2, 4, 6, 8]"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "its_odd(range(10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 2, 4, 6, 8]"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "xx = its_odd\n",
    "xx(range(10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def save_to_file(func, input_seq, filename, str_format=u'{} --> {}'):\n",
    "    output_seq = func(input_seq)\n",
    "    f = open(filename, 'w')\n",
    "    # TODO: 문자열 인코딩 수행\n",
    "    text_encoded = str_format.format(input_seq, output_seq).encode('utf-8')\n",
    "    f.write(text_encoded)\n",
    "    f.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "save_to_file(its_odd, [1,2,3,4,5], 'its_odd_result.txt')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def its_even(seq):\n",
    "    return seq[1::2]\n",
    "\n",
    "save_to_file(its_even, [1,2,3,4,5], 'its_even_result.txt')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "그런데, 유니코드 저장을 하려고 하니까 ... ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "save_to_file(its_odd, u'파이썬', 'its_odd_result.txt')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 도전과제\n",
    "\n",
    "피보나치 수열은 다음과 같다.\n",
    "\n",
    "0 1 1 2 3 5 8 ... \n",
    "\n",
    "a. 임의의 n개의 피보나치 수열을 리스트로 반환하는 함수 generate_fibo를 작성하시오.\n",
    "\n",
    "b. generate_fibo 호출 시, 시작 숫자 두 개를 지정할 수 있도록 하시오. 인자를 설정하지 않으면 수열은 0,1로 시작한다. 생성 개수를 지정하지 않으면, 기본적으로 10개의 숫자를 생성하도록 만드시오."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def generate_fibo(a=0,b=1,n=10):\n",
    "    fibos = [a,b]\n",
    "    # 지정된 개수만큼 원소 추가\n",
    "    while len(fibos)<n:\n",
    "        # 새 원소 생성 후 a, b 값 교체\n",
    "        a,b = (b, a+b)\n",
    "        # 새로 생성된 값을 결과에 추가\n",
    "        fibos.append(b)\n",
    "    \n",
    "    return fibos\n",
    "\n",
    "generate_fibo()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 도전과제\n",
    "\n",
    "포커 카드 52장을 게임 참가자에게 각각 5장씩 나눠주는 프로그램을 작성하시오. 포커 카드는 참가자에게 나눠주기 전에 무작위로 섞여야 한다. 참가자의 수는 2-4명이 될 수 있다.\n",
    "\n",
    "a. 포커 카드를 나눠주고 나서 각 참가자가 받은 포커 카드를 모두 출력한다.\n",
    "\n",
    "예:\n",
    "\n",
    "이성주 : H2, D2, SJ, C10, S3\n",
    "\n",
    "김성주 : C3, D4, CK, SK, H9\n",
    "\n",
    "b. 각 참자자의 카드의 숫자를 기준으로 오름차순으로 정렬해 출력한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from __future__ import print_function\n",
    "import random\n",
    "\n",
    "# 1. 카드덱 생성\n",
    "def generate_card():\n",
    "    # 52장 카드 덱 생성\n",
    "    suits = ['Heart', 'Diamond', 'Clover', 'Spade']\n",
    "    ranks = range(2,11)+['J', 'Q', 'K', 'A']\n",
    "    deck = []\n",
    "    for s in suits:\n",
    "        for r in ranks:\n",
    "            card = s + str(r)\n",
    "            deck.append(card)\n",
    "    return deck\n",
    "\n",
    "# 2. 카드덱 나눠주기\n",
    "def play_card_game(deck, players):\n",
    "    # 나눠주기 전에 섞어야지\n",
    "    random.shuffle(deck)\n",
    "    \n",
    "    # 인제 나눠줘야지 ...\n",
    "    for person in players:\n",
    "        person['hand'] = deck[:5]\n",
    "        deck = deck[5:]\n",
    "        \n",
    "    return"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "52\n",
      "이성주: ['Spade3', 'SpadeA', 'Heart5', 'Spade5', 'DiamondJ']\n",
      "김성주: ['Diamond10', 'SpadeQ', 'Heart8', 'Diamond6', 'Heart9']\n"
     ]
    }
   ],
   "source": [
    "deck = generate_card()\n",
    "players = [{'name':'이성주'}, {'name':'김성주'}]\n",
    "play_card_game(deck, players)\n",
    "\n",
    "print(len(deck))\n",
    "\n",
    "for person in players:\n",
    "    print(person['name'], end=': ')\n",
    "    print(person['hand'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 도전과제\n",
    "52장의 포커 카드가 있다. 이 카드를 사용해 블랙잭 게임을 한다.\n",
    "\n",
    "블랙잭 게임은 각 참가자가 처음에 두 장의 카드를 받는다.\n",
    "각 카드의 숫자를 모두 더 해 21인지 확인한다.\n",
    "\n",
    "- 21이면 블랙잭! 게임이 종료되고 승리한다.\n",
    "- 숫자의 합이 21보다 작으면 한 장의 카드를 더 받는다.\n",
    "- 숫자의 합이 21보다 크면 게임에서 패배한다.\n",
    "\n",
    "a. 받은 카드패를 파일로 출력해 저장한다.\n",
    "\n",
    "참가자: 이성주\n",
    "\n",
    "2015-07-08\n",
    "\n",
    "HJ, HK 패!\n",
    "\n",
    "HJ, S10 블랙잭!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "카드패: [('Diamond', 'K'), ('Clover', 6)]\n",
      "카드 숫자값= 19\n",
      "인생을 계속 살아봐야 아는 거지 ... 한 장 더\n",
      "\n",
      "카드패: [('Diamond', 'K'), ('Clover', 6), ('Clover', 2)]\n",
      "카드 숫자값= 21\n",
      "블랙잭!!!!!!!\n",
      "\n"
     ]
    }
   ],
   "source": [
    "from __future__ import print_function\n",
    "import random\n",
    "\n",
    "# 52장의 카드덱 생성\n",
    "def gen_deck():\n",
    "    ranks = list(range(2,11))+['J', 'Q', 'K', 'A']\n",
    "    suits = ['Spade', 'Heart', 'Diamond', 'Clover']\n",
    "    \n",
    "    deck = [] # 카드덱 초기화\n",
    "    for s in suits:\n",
    "        for r in ranks:\n",
    "            deck.append((s, r))\n",
    "            \n",
    "    # 잘 섞기\n",
    "    random.shuffle(deck)\n",
    "    return deck\n",
    "\n",
    "def get_card_value(hand):\n",
    "    \"\"\"카드패의 숫자값 합계\"\"\"\n",
    "    # 현재 hand의 카드의 숫자를 모두 더한다.\n",
    "    value=0\n",
    "    for card in hand:\n",
    "        # 현재 카드의 숫자값\n",
    "        rank = card[1]\n",
    "        if rank=='A':\n",
    "            value = value + 14\n",
    "        elif rank=='K':\n",
    "            value = value + 13\n",
    "        elif rank == 'Q':\n",
    "            value = value + 12\n",
    "        elif rank == 'J':\n",
    "            value = value + 11\n",
    "        else:\n",
    "            # 숫자인 경우는 그냥 더해준다.\n",
    "            value = value + rank\n",
    "                \n",
    "    return value\n",
    "\n",
    "def play_blackjack(player, output_file=None):\n",
    "    # 블랙잭 게임 시작\n",
    "    deck=gen_deck()\n",
    "\n",
    "    # 카드 두 장 받기\n",
    "    player['hand'] = [deck.pop(), deck.pop()]\n",
    "\n",
    "    while True:\n",
    "        play_log = u'카드패: {}'.format(player['hand'])\n",
    "        play_log += u'\\n'\n",
    "\n",
    "        # 카드패 숫자값 합계\n",
    "        hand_value = get_card_value(player['hand'])\n",
    "\n",
    "        play_log += u'카드 숫자값= {}'.format(hand_value)\n",
    "        play_log += u'\\n'\n",
    "        if hand_value == 21:\n",
    "            play_log += u'블랙잭!!!!!!!' \n",
    "            play_log += u'\\n'\n",
    "            print(play_log)\n",
    "            break\n",
    "        elif hand_value > 21:\n",
    "            play_log += u'돈 잃었다...'\n",
    "            play_log += '\\n'\n",
    "            print(play_log)\n",
    "            break\n",
    "        elif hand_value < 21:\n",
    "            # 카드를 한 장 더 받는다.\n",
    "            player['hand'].append(deck.pop())\n",
    "            play_log += u'인생을 계속 살아봐야 아는 거지 ... 한 장 더'\n",
    "            play_log += u'\\n'\n",
    "            print(play_log)\n",
    "            \n",
    "    # 게임 결과를 파일로 출력\n",
    "    if output_file is not None:\n",
    "        f = open(output_file, 'a')\n",
    "        text_encoded = play_log.encode('utf-8')\n",
    "        f.write(text_encoded)\n",
    "        f.close()\n",
    "            \n",
    "play_blackjack({'name':u'이성주'}, output_file='blackjack_log.txt')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[('Spade', 10), ('Clover', 2), ('Spade', 5)]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "17"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "deck = gen_deck()\n",
    "hand = deck[:3]\n",
    "print(hand)\n",
    "get_card_value(hand)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 도전과제\n",
    "\n",
    "5개의 임의의 카드패 100개 정보를 담은 파일을 생성한다. 이 파일의 각 카드패에 포커 (같은 숫자 4개)가 있는지 확인하는 프로그램을 작성한다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "abc\n"
     ]
    }
   ],
   "source": [
    "# list의 원소를 문자열로 반환하는 구문\n",
    "text = ''\n",
    "for c in ['a','b','c']:\n",
    "    text += c\n",
    "print(text)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Spade 6\n"
     ]
    }
   ],
   "source": [
    "# sequence 형의 원소를 문자열로 반환\n",
    "# 파이썬 표준 라이브러리 활용\n",
    "import string\n",
    "text = string.join(('Spade', str(6)), sep=' ')\n",
    "print(text)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['a', 'b', 'c']"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 문자열을 list로 변환\n",
    "'a,b,c'.split(',')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import string\n",
    "\n",
    "def card_to_string(card):\n",
    "    return string.join((str(card[0]), str(card[1])), sep=' ')\n",
    "\n",
    "def gen_hands(filename = 'hand_100.txt', n=100):\n",
    "    # 카드패 파일 생성\n",
    "    f = open(filename, 'w')\n",
    "    for i in range(n):\n",
    "        hand = gen_deck()[:5]\n",
    "        # 카드패 정보를 문자열로 변환\n",
    "        for card in hand:\n",
    "            card_str = card_to_string(card)\n",
    "            f.write(card_str)\n",
    "            f.write(',')\n",
    "        f.write('\\n')\n",
    "    \n",
    "    f.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from __future__ import print_function\n",
    "\n",
    "def is_pocker(hand):\n",
    "    \"\"\"카드패가 포커(4장의 같은 숫자 포함)인지 확인\"\"\"\n",
    "    # TODO: 포커 탐지\n",
    "    \"\"\"\n",
    "    X O O O O\n",
    "    O X O O O\n",
    "    O O X O O\n",
    "    O O O X O\n",
    "    O O O O X\n",
    "    \"\"\"\n",
    "    # 카드패에서 숫자만 추출\n",
    "    ranks = []\n",
    "    for card in hand:\n",
    "        ranks.append(str(card[1]))\n",
    "\n",
    "    #print(ranks) # 디버깅용 출력\n",
    "    \n",
    "    # 자료 구조를 바꾸는 방법\n",
    "    # 더 좋은 방법을 찾아야 할 듯 ...\n",
    "    if len(set(ranks)) == 2:\n",
    "        return True\n",
    "    \n",
    "    return False\n",
    "\n",
    "def to_list(hand_str_list):\n",
    "    hand_list = []\n",
    "    for l in hand_str_list:\n",
    "        # 카드패를 list로 변환\n",
    "        hand_str = l.split(',')[:-1]\n",
    "        # 카드패의 각 원소를 튜플로 변환\n",
    "        hand = []\n",
    "        for card in hand_str:\n",
    "            hand.append(tuple(card.split()))\n",
    "        hand_list.append(hand)\n",
    "    return hand_list\n",
    "\n",
    "def check_pockers(filename):\n",
    "    \"\"\"파일을 읽어들여, 카드패에서 포커 패턴 탐지\"\"\"\n",
    "    f = open(filename)\n",
    "    hand_list = to_list(f.readlines())\n",
    "    f.close() # 파일 읽기 종료\n",
    "    \n",
    "    # 각 패의 포커 탐지\n",
    "    for hand in hand_list:\n",
    "        if is_pocker(hand):\n",
    "            print(hand, end=': ')\n",
    "            print('포커!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "is_pocker([('H',7), ('D',7), ('S',7), ('D',2), ('C',7)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[('Diamond', 'K'), ('Diamond', 'J'), ('Clover', 'J'), ('Heart', 'K'), ('Clover', 'K')]: 포커!\n",
      "[('Clover', '2'), ('Heart', '2'), ('Spade', '2'), ('Spade', '9'), ('Heart', '9')]: 포커!\n",
      "[('Diamond', '5'), ('Spade', '5'), ('Spade', '3'), ('Clover', '3'), ('Clover', '5')]: 포커!\n",
      "[('Clover', '8'), ('Spade', '6'), ('Heart', '6'), ('Clover', '6'), ('Diamond', '8')]: 포커!\n",
      "[('Spade', '6'), ('Spade', 'Q'), ('Diamond', 'Q'), ('Heart', '6'), ('Clover', '6')]: 포커!\n",
      "[('Clover', '3'), ('Clover', '4'), ('Heart', '4'), ('Heart', '3'), ('Spade', '3')]: 포커!\n",
      "[('Heart', 'A'), ('Heart', '9'), ('Clover', 'A'), ('Diamond', 'A'), ('Spade', 'A')]: 포커!\n",
      "[('Heart', '7'), ('Diamond', '9'), ('Spade', '9'), ('Diamond', '7'), ('Clover', '7')]: 포커!\n",
      "[('Spade', 'K'), ('Clover', 'K'), ('Diamond', '3'), ('Clover', '3'), ('Heart', '3')]: 포커!\n",
      "[('Spade', 'Q'), ('Spade', 'K'), ('Heart', 'Q'), ('Clover', 'Q'), ('Diamond', 'Q')]: 포커!\n",
      "[('Spade', '7'), ('Heart', '7'), ('Clover', '7'), ('Clover', '5'), ('Heart', '5')]: 포커!\n",
      "[('Clover', '3'), ('Clover', '8'), ('Diamond', '3'), ('Spade', '8'), ('Heart', '3')]: 포커!\n",
      "[('Clover', '4'), ('Spade', '6'), ('Heart', '4'), ('Heart', '6'), ('Clover', '6')]: 포커!\n",
      "[('Spade', '6'), ('Heart', '6'), ('Spade', '2'), ('Heart', '2'), ('Diamond', '6')]: 포커!\n",
      "[('Heart', 'A'), ('Clover', '5'), ('Spade', '5'), ('Clover', 'A'), ('Heart', '5')]: 포커!\n",
      "[('Heart', 'Q'), ('Diamond', 'Q'), ('Heart', '4'), ('Spade', 'Q'), ('Diamond', '4')]: 포커!\n",
      "[('Heart', '7'), ('Heart', 'Q'), ('Diamond', '7'), ('Clover', '7'), ('Spade', 'Q')]: 포커!\n",
      "[('Clover', '8'), ('Spade', '8'), ('Heart', '8'), ('Heart', '9'), ('Clover', '9')]: 포커!\n",
      "[('Clover', '7'), ('Spade', '6'), ('Clover', '6'), ('Diamond', '6'), ('Heart', '7')]: 포커!\n",
      "[('Diamond', '6'), ('Diamond', '5'), ('Heart', '5'), ('Spade', '6'), ('Heart', '6')]: 포커!\n",
      "[('Spade', 'J'), ('Clover', '9'), ('Diamond', '9'), ('Heart', '9'), ('Spade', '9')]: 포커!\n",
      "[('Diamond', 'J'), ('Diamond', '4'), ('Heart', '4'), ('Spade', '4'), ('Spade', 'J')]: 포커!\n",
      "[('Spade', '7'), ('Spade', '8'), ('Clover', '8'), ('Heart', '8'), ('Diamond', '7')]: 포커!\n"
     ]
    }
   ],
   "source": [
    "filename = 'hand_10000.txt'\n",
    "gen_hands(filename, n=10000)\n",
    "check_pockers(filename)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 도전과제\n",
    "카드의 모음을 패(hand)라고 한다. 카드패에서 다음의 경우를 판정하는 프로그램을 작성한다.\n",
    "1. 같은 숫자 네 개가 있는 경우\n",
    "2. 숫자 다섯 개가 연속되는 경우\n",
    "3. 같은 문양이 다섯 개인 경우\n",
    "4. 같은 숫자 쌍이 있는 경우"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "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.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}