Python Day 2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Day 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "0\n",
      "0\n",
      "0\n",
      "0\n",
      "1\n",
      "1\n",
      "0\n",
      "1\n",
      "2\n",
      "2\n",
      "4\n",
      "0\n",
      "2\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "for i in range(3):\n",
    "    print(i)\n",
    "    print(i**2)\n",
    "    for j in range(3):\n",
    "        print(i * j)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "### 2단 ###\n",
      "2 * 1 = 2\n",
      "2 * 2 = 4\n",
      "2 * 3 = 6\n",
      "2 * 4 = 8\n",
      "2 * 5 = 10\n",
      "2 * 6 = 12\n",
      "2 * 7 = 14\n",
      "2 * 8 = 16\n",
      "2 * 9 = 18\n"
     ]
    }
   ],
   "source": [
    "# 구구단 2단을 출력하는 코드\n",
    "# 두번째 줄\n",
    "print('### 2단 ###')\n",
    "for i in range(1, 10):  # 1이상 10미만 범위에서 루프를 돕니다.\n",
    "    print('{} * {} = {}'.format(2, i, 2*i))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## 흐름 제어 (제어 구조)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "숫자를 입력해주세요.0\n",
      "0입니다.\n"
     ]
    }
   ],
   "source": [
    "number = int(input('숫자를 입력해주세요.'))\n",
    "\n",
    "if number > 0:\n",
    "    print('양수입니다.')\n",
    "else:  # 아니라면\n",
    "    if number < 0:\n",
    "        print('음수입니다.')\n",
    "    else:\n",
    "        print('0입니다.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0입니다.\n"
     ]
    }
   ],
   "source": [
    "if number > 0:\n",
    "    print('양수입니다.')\n",
    "elif number < 0:\n",
    "    print('음수입니다.')\n",
    "else:\n",
    "    print('0입니다.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0입니다.\n"
     ]
    }
   ],
   "source": [
    "if number > 0:\n",
    "    print('양수입니다.')\n",
    "\n",
    "if number < 0:\n",
    "    print('음수입니다.')\n",
    "\n",
    "if number == 0:\n",
    "    print('0입니다.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter Number : 123\n",
      "100의 자리수입니다.\n"
     ]
    }
   ],
   "source": [
    "number = int(input('Enter Number : '))\n",
    "\n",
    "if number < 0:\n",
    "    print('음수입니다.')\n",
    "\n",
    "# if 0 <= number < 10:  # 파이썬만 가능한 문법\n",
    "\n",
    "if 0 <= number and number < 10:\n",
    "    print('1의 자리수입니다.')\n",
    "if 10 <= number and number < 100:\n",
    "    print('10의 자리 수입니다.')\n",
    "if 100 <= number and number < 1000:\n",
    "    print('100의 자리수입니다.')\n",
    "if number >= 1000:\n",
    "    print('난 몰라. 너무 크다.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter Number : 123\n",
      "100의 자리수입니다.\n"
     ]
    }
   ],
   "source": [
    "number = int(input('Enter Number : '))\n",
    "\n",
    "if number < 0:\n",
    "    print('음수입니다.')\n",
    "elif number < 10:\n",
    "    print('1의 자리수입니다.')\n",
    "elif number < 100:\n",
    "    print('10의 자리수입니다.')\n",
    "elif number < 1000:\n",
    "    print('100의 자리수입니다.')\n",
    "else:\n",
    "    print('난 몰라. 너무 크다.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 반복문"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "for i in [1, 2, 3]:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "[4, 5, 6]\n",
      "7\n"
     ]
    }
   ],
   "source": [
    "for i in [1, 2, 3, [4, 5, 6], 7]:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 * 1 = 2\n",
      "2 * 2 = 4\n",
      "2 * 3 = 6\n",
      "4 * 1 = 4\n",
      "4 * 2 = 8\n",
      "4 * 3 = 12\n"
     ]
    }
   ],
   "source": [
    "for i in range(2, 10):\n",
    "    # print(i)\n",
    "    if i == 3:\n",
    "        continue\n",
    "    if i == 5:\n",
    "        break\n",
    "    for j in range(1, 10):\n",
    "        print('{} * {} = {}'.format(i, j, i*j))\n",
    "        if j == 3:\n",
    "            break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "4\n",
      "9\n",
      "16\n",
      "25\n"
     ]
    }
   ],
   "source": [
    "for i in range(10):\n",
    "    if i > 5:\n",
    "        continue\n",
    "    print(i**2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "4\n",
      "9\n",
      "16\n",
      "25\n"
     ]
    }
   ],
   "source": [
    "for i in range(10):\n",
    "    if i <= 5:\n",
    "        print(i**2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "# for i in range(10):\n",
    "#     print(i)\n",
    "\n",
    "i = 0\n",
    "while i < 10:\n",
    "    print(i)\n",
    "    i += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 함수 (Functions)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "### 2 단 ###\n",
      "2 * 1 = 2\n",
      "2 * 2 = 4\n",
      "2 * 3 = 6\n",
      "2 * 4 = 8\n",
      "2 * 5 = 10\n",
      "2 * 6 = 12\n",
      "2 * 7 = 14\n",
      "2 * 8 = 16\n",
      "2 * 9 = 18\n",
      "### 3 단 ###\n",
      "3 * 1 = 3\n",
      "3 * 2 = 6\n",
      "3 * 3 = 9\n",
      "3 * 4 = 12\n",
      "3 * 5 = 15\n",
      "3 * 6 = 18\n",
      "3 * 7 = 21\n",
      "3 * 8 = 24\n",
      "3 * 9 = 27\n",
      "### 4 단 ###\n",
      "4 * 1 = 4\n",
      "4 * 2 = 8\n",
      "4 * 3 = 12\n",
      "4 * 4 = 16\n",
      "4 * 5 = 20\n",
      "4 * 6 = 24\n",
      "4 * 7 = 28\n",
      "4 * 8 = 32\n",
      "4 * 9 = 36\n",
      "### 5 단 ###\n",
      "5 * 1 = 5\n",
      "5 * 2 = 10\n",
      "5 * 3 = 15\n",
      "5 * 4 = 20\n",
      "5 * 5 = 25\n",
      "5 * 6 = 30\n",
      "5 * 7 = 35\n",
      "5 * 8 = 40\n",
      "5 * 9 = 45\n"
     ]
    }
   ],
   "source": [
    "number = 2\n",
    "print('*** {} 단 ***'.format(number))\n",
    "for i in range(1, 10):\n",
    "    print('{} * {} = {}'.format(number, i, number*i))\n",
    "\n",
    "number = 3\n",
    "print('### {} 단 ###'.format(number))\n",
    "for i in range(1, 10):\n",
    "    print('{} * {} = {}'.format(number, i, number*i))\n",
    "    \n",
    "number = 4\n",
    "print('### {} 단 ###'.format(number))\n",
    "for i in range(1, 10):\n",
    "    print('{} * {} = {}'.format(number, i, number*i))\n",
    "    \n",
    "number = 5\n",
    "print('### {} 단 ###'.format(number))\n",
    "for i in range(1, 10):\n",
    "    print('{} * {} = {}'.format(number, i, number*i))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def print_gugudan(number):\n",
    "    print('#$#$ {} 단 #$#$'.format(number))\n",
    "\n",
    "#     for i in range(2, 10, 2):\n",
    "#         print('{} * {} = {}'.format(number, i, number*i))\n",
    "\n",
    "    for i in range(1, 10):\n",
    "        if i % 2 == 0:\n",
    "            print('{} * {} = {}'.format(number, i, number*i))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "#$#$ 2 단 #$#$\n",
      "2 * 2 = 4\n",
      "2 * 4 = 8\n",
      "2 * 6 = 12\n",
      "2 * 8 = 16\n",
      "#$#$ 3 단 #$#$\n",
      "3 * 2 = 6\n",
      "3 * 4 = 12\n",
      "3 * 6 = 18\n",
      "3 * 8 = 24\n",
      "#$#$ 4 단 #$#$\n",
      "4 * 2 = 8\n",
      "4 * 4 = 16\n",
      "4 * 6 = 24\n",
      "4 * 8 = 32\n",
      "#$#$ 5 단 #$#$\n",
      "5 * 2 = 10\n",
      "5 * 4 = 20\n",
      "5 * 6 = 30\n",
      "5 * 8 = 40\n"
     ]
    }
   ],
   "source": [
    "print_gugudan(2)\n",
    "print_gugudan(3)\n",
    "print_gugudan(4)\n",
    "print_gugudan(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def mysum2(x, y):\n",
    "    return x + y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result = mysum2(1, 2)\n",
    "result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def mysum3(x, y, z):\n",
    "    return x + y + z + 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "16"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mysum3(1, 2, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def print_gugudan(number):\n",
    "    print('{}단을 출력할 예정이야.'.format(number))\n",
    "#     return None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2단을 출력할 예정이야.\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "print(print_gugudan(2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def mycalc(x, y):\n",
    "    if x > 0:\n",
    "        return x + y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "13"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "result = mycalc(1, 2) + 10\n",
    "result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for +: 'NoneType' and 'int'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-69-fa6f982d16ad>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmycalc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;36m10\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      2\u001b[0m \u001b[0mresult\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'NoneType' and 'int'"
     ]
    }
   ],
   "source": [
    "result = mycalc(-1, 2) + 10\n",
    "result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def mysum2(x, y):\n",
    "    return x * 10 + y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mysum2(1, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "21"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mysum2(2, 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mysum2(x=1, y=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mysum2(y=2, x=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fn = mysum2\n",
    "fn(1, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 익명함수"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<function __main__.mysum2>"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mysum2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<function __main__.<lambda>>"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# def ???(x, y):\n",
    "#     return x * 10 + y\n",
    "\n",
    "lambda x, y: x * 10 + y  # result문이 없습니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(lambda x, y: x * 10 + y)(1, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<function __main__.<lambda>>"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mysum2_anon = lambda x, y: x * 10 + y\n",
    "mysum2_anon"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mysum2_anon(1, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1급 함수"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def fn(x, y):\n",
    "    result = x + y  # result라는 새로운 변수가 생성\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fn(1, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def fn2(x, y):\n",
    "    myfn = lambda a, b: a + b\n",
    "    return x + y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fn2(1, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def base10():\n",
    "    fn = lambda x, y: x + y + 10\n",
    "    return fn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "13"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "return_fn = base10()\n",
    "return_fn(1, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def base10(x, y):\n",
    "    return x + y + 10\n",
    "\n",
    "def base20(x, y):\n",
    "    return x + y + 20\n",
    "\n",
    "def base30(x, y):\n",
    "    return x + y + 30\n",
    "\n",
    "def base(base_number):\n",
    "    fn = lambda x, y: x + y + base_number\n",
    "    return fn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "13"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "base10(1, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "13"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "base(10)(1, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def using_fn(fn, x, y):\n",
    "    return fn(x, y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "30"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "using_fn(lambda a, b: a + b, 10, 20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "200"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "using_fn(lambda a, b: a * b, 10, 20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def convert(data, rule_fn):\n",
    "    result = rule_fn(data)\n",
    "    print(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Hello', 'World']\n"
     ]
    }
   ],
   "source": [
    "def split_fn(s):\n",
    "    return s.split()  # white space 기준으로 쪼개어줍니다.\n",
    "\n",
    "convert('Hello World', split_fn)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd']\n"
     ]
    }
   ],
   "source": [
    "def split_character_fn(s):\n",
    "    return list(s)\n",
    "\n",
    "convert('Hello World', split_character_fn)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 실전 예시"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def convert(data, rule_fn):\n",
    "    converted_list = []\n",
    "#     data  # 여러 줄 데이터\n",
    "    for line in data.splitlines():  # 여러 줄을 줄 별로 끊어서, list화\n",
    "        converted_list.append(rule_fn(line))  # rule_fn을 통해 각 컬럼들을 구분\n",
    "    return converted_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[['이진석', '90', '80', '70'],\n",
       " ['공유', '100', '95', '60'],\n",
       " ['아이유', '70', '80', '60']]"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "raw_data = '''이진석,90,80,70\n",
    "공유,100,95,60\n",
    "아이유,70,80,60'''\n",
    "\n",
    "def convert_by_comma(line):\n",
    "    return line.split(',')\n",
    "\n",
    "convert(raw_data, convert_by_comma)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[['이진석', '90', '80', '70'],\n",
       " ['공유', '100', '95', '60'],\n",
       " ['아이유', '70', '80', '60']]"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "raw_data = '''이진석|90|80|70\n",
    "공유|100|95|60\n",
    "아이유|70|80|60'''\n",
    "\n",
    "def convert_by_pipe(line):\n",
    "    return line.split('|')\n",
    "\n",
    "convert(raw_data, convert_by_pipe)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 클래스"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello\n",
      "world\n"
     ]
    }
   ],
   "source": [
    "if 1 > 0:\n",
    "    print('hello')\n",
    "    pass\n",
    "    print('world')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class Person:\n",
    "    def __init__(self, name, age, region):  # 생성자, Constructor\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "        self.region = region\n",
    "    \n",
    "    def say_hello(self):\n",
    "        print('안녕하세요. {}님. {}살이시네요. {}에서 오셨군요.'.format(\n",
    "            self.name, self.age, self.region\n",
    "        ))\n",
    "    \n",
    "    def move_to(self, destination):\n",
    "        self.region = destination"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tom\n",
      "10\n",
      "안녕하세요. Tom님. 10살이시네요. 서울에서 오셨군요.\n",
      "안녕하세요. Tom님. 10살이시네요. 상해에서 오셨군요.\n"
     ]
    }
   ],
   "source": [
    "tom = Person('Tom', 10, '서울')\n",
    "print(tom.name)\n",
    "print(tom.age)\n",
    "tom.say_hello()\n",
    "tom.move_to('상해')\n",
    "tom.say_hello()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Steve\n",
      "12\n",
      "안녕하세요. Steve님. 12살이시네요. 부산에서 오셨군요.\n"
     ]
    }
   ],
   "source": [
    "steve = Person('Steve', 12, '부산')\n",
    "print(steve.name)\n",
    "print(steve.age)\n",
    "steve.say_hello()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 퀴즈"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "사각형 클래스 (Rectangle) 를 만들어보세요.\n",
    "\n",
    "생성자에 필요한 속성\n",
    "\n",
    "* 가로 크기 : 정수형\n",
    "* 세로 크기 : 정수형"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "200\n",
      "600\n"
     ]
    }
   ],
   "source": [
    "class Rectangle:\n",
    "    def __init__(self, width, height):\n",
    "        self.width = width\n",
    "        self.height = height\n",
    "       \n",
    "    def get_area(self):\n",
    "        return self.width * self.height\n",
    "\n",
    "rect1 = Rectangle(10, 20)\n",
    "rect2 = Rectangle(40, 15)\n",
    "\n",
    "print(rect1.get_area())  # 10 * 20 => 200\n",
    "print(rect2.get_area())  # 40 * 15 => 600"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "rect1 = Rectangle(10, 20)  # python\n",
    "\n",
    "rect1 = Rectangle.new(10, 20)  # ruby\n",
    "\n",
    "Rectangle rect1 = new Rectangle(10, 20);  # java"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 순회가능한 객체"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# 리스트/튜플은 넣은 순서를 유지해주지만,\n",
    "# 집합/사전은 넣은 순서를 포기하고, 성능을 선택.\n",
    "movies = {\n",
    "    '그것만이 내 세상',\n",
    "    '1급 기밀',\n",
    "    '코코',\n",
    "    '커뮤터',\n",
    "    '비밥바룰라',\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "코코\n",
      "그것만이 내 세상\n",
      "커뮤터\n",
      "1급 기밀\n",
      "비밥바룰라\n"
     ]
    }
   ],
   "source": [
    "for name in movies:\n",
    "    print(name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 빌트인 함수 정렬"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### sorted"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[62, 46, 37, 71, 30, 31, 40, 80, 90, 69]"
      ]
     },
     "execution_count": 164,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import random\n",
    "\n",
    "numbers = []\n",
    "for i in range(10):\n",
    "    numbers.append(random.randint(1, 100))\n",
    "numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[30, 31, 37, 40, 46, 62, 69, 71, 80, 90]"
      ]
     },
     "execution_count": 165,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorted(numbers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[90, 80, 71, 69, 62, 46, 40, 37, 31, 30]"
      ]
     },
     "execution_count": 167,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorted(numbers, reverse=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[30, 40, 80, 90, 71, 31, 62, 46, 37, 69]"
      ]
     },
     "execution_count": 168,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def sort_fn(value):\n",
    "    return value % 10\n",
    "\n",
    "sorted(numbers, key=sort_fn)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### filter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 169,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[62, 46, 37, 71, 30, 31, 40, 80, 90, 69]"
      ]
     },
     "execution_count": 169,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[62, 46, 30, 40, 80, 90]"
      ]
     },
     "execution_count": 171,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# filter 안 쓰면\n",
    "even_numbers = []\n",
    "\n",
    "for number in numbers:\n",
    "    if number % 2 == 0:\n",
    "        even_numbers.append(number)\n",
    "\n",
    "even_numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 179,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "62\n",
      "46\n",
      "30\n",
      "40\n",
      "80\n",
      "90\n"
     ]
    }
   ],
   "source": [
    "def hello_fn(value):\n",
    "    return value % 2 == 0\n",
    "\n",
    "for i in filter(hello_fn, numbers):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 177,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(62, 46, 30, 40, 80, 90)"
      ]
     },
     "execution_count": 177,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tuple(filter(filter_fn, numbers))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 178,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<filter at 0x10f3fa0b8>"
      ]
     },
     "execution_count": 178,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "filter(filter_fn, numbers)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### map"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 180,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[62, 46, 37, 71, 30, 31, 40, 80, 90, 69]"
      ]
     },
     "execution_count": 180,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 183,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 6, 7, 1, 0, 1, 0, 0, 0, 9]"
      ]
     },
     "execution_count": 183,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def map_fn(value):\n",
    "    return value % 10\n",
    "\n",
    "list(map(map_fn, numbers))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 192,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "address_list = [\n",
    "    '서울시 성동구 A동 111번지',\n",
    "    '서울시 강북구 B동 123번지',\n",
    "    '서울시 강남구 C동 12312-1231번지',\n",
    "    '서울시 성동구 D동 11-33번지',\n",
    "    '서울시 북구 E동 90-32번지',\n",
    "    '서울시 강남구 C동 12312-1231번지',\n",
    "    '서울시 강남구 C동 12312-1231번지',\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 193,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'A동'"
      ]
     },
     "execution_count": 193,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "address = '서울시 성동구 A동 111번지'\n",
    "address.split()[-2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 194,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['A동', 'B동', 'C동', 'D동', 'E동', 'C동', 'C동']"
      ]
     },
     "execution_count": 194,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def 동정보뽑기(address):\n",
    "    return address.split()[-2]\n",
    "\n",
    "list(map(동정보뽑기, address_list))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 195,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'A동', 'B동', 'C동', 'D동', 'E동'}"
      ]
     },
     "execution_count": 195,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set(map(동정보뽑기, address_list))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### min/max"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 196,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[62, 46, 37, 71, 30, 31, 40, 80, 90, 69]"
      ]
     },
     "execution_count": 196,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 197,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "90"
      ]
     },
     "execution_count": 197,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "max(numbers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 198,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "30"
      ]
     },
     "execution_count": 198,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "min(numbers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 199,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "mynumbers = []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 201,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 201,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "max(mynumbers, default=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### list의 sort함수"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 202,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[62, 46, 37, 71, 30, 31, 40, 80, 90, 69]"
      ]
     },
     "execution_count": 202,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 204,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[30, 31, 37, 40, 46, 62, 69, 71, 80, 90]"
      ]
     },
     "execution_count": 204,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorted(numbers)  # 순횐가능한 객체는 다 가능하며, source를 변경하지 않는다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 205,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "numbers.sort()  # list에서만 가능하며, 자가지신을 정렬/변경시킨다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 206,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[30, 31, 37, 40, 46, 62, 69, 71, 80, 90]"
      ]
     },
     "execution_count": 206,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numbers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 대소비교"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 209,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "65"
      ]
     },
     "execution_count": 209,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ord('A')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 208,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "98"
      ]
     },
     "execution_count": 208,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ord('b')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 210,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 210,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'a' < 'b'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 211,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 211,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'abc' < 'z'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 212,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 212,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "['a', 'b', 'c'] < ['z']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 214,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 214,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "0 < int('1')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 과제 : 다수 기준으로 정렬하기"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[9, 10, 20, 11, 12, 211, 121, 313]\n"
     ]
    }
   ],
   "source": [
    "def sort_fn(value):\n",
    "    # return len(str(value))  # 1차 기준만\n",
    "    # return value % 10       # 2차 기준만\n",
    "    length = len(str(value))\n",
    "    remain = value % 10\n",
    "    return [length, remain]\n",
    "\n",
    "mylist = [10, 11, 9, 20, 12, 313, 211, 121]\n",
    "\n",
    "mylist.sort(key=sort_fn)\n",
    "# mylist = sorted(mylist, key=sort_fn)\n",
    "\n",
    "print(mylist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 자릿수\n",
    "number = 123\n",
    "len(str(number))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 과제"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " * Person 클래스 : 이름, 국어, 영어, 수학 성적을 input을 통해 입력받아서, Person 클래스의 list\n",
    " \n",
    "```python\n",
    "이름, 국어, 영어, 수학 = ...\n",
    "person1 = Person(이름, 국어, 영어, 수학)  # for 루프화\n",
    "person2 = Person(이름, 국어, 영어, 수학)\n",
    "\n",
    "person_list.append(person1)\n",
    "```\n",
    "\n",
    " * 국어성적 랭킹 TOP 3\n",
    " * 영어성적 랭킹 TOP 3\n",
    " * 수학성적 랭킹 TOP 3\n",
    " * 총점 랭킹 TOP 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "입력해주세요. : 이진석, 100, 90, 80\n",
      "입력해주세요. : 공유, 80, 85, 90\n",
      "입력해주세요. : 아이유, 95, 85, 80\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'\\n이진석, 100, 90, 80\\n공유, 80, 85, 90\\n아이유, 95, 85, 80\\n'"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Person:\n",
    "    def __init__(self, 이름, 국어, 영어, 수학):\n",
    "        self.이름 = 이름\n",
    "        self.국어 = 국어\n",
    "        self.영어 = 영어\n",
    "        self.수학 = 수학\n",
    "\n",
    "    def 총점구하기(self):\n",
    "        return (self.국어 + self.영어 + self.수학)\n",
    "        \n",
    "    def 평균구하기(self):\n",
    "        return self.총점구하기() // 3\n",
    "\n",
    "person_list = []\n",
    "        \n",
    "for i in range(3):\n",
    "    line = input('입력해주세요. : ')\n",
    "    이름, 국어, 영어, 수학 = line.split(', ')\n",
    "    person = Person(이름, int(국어), int(영어), int(수학))\n",
    "    person_list.append(person)\n",
    "    \n",
    "'''\n",
    "이진석, 100, 90, 80\n",
    "공유, 80, 85, 90\n",
    "아이유, 95, 85, 80\n",
    "'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<__main__.Person at 0x10f4d9438>,\n",
       " <__main__.Person at 0x111fcbdd8>,\n",
       " <__main__.Person at 0x10f4d9cf8>]"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "person_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "이진석 270 90\n",
      "공유 255 85\n",
      "아이유 260 86\n"
     ]
    }
   ],
   "source": [
    "for person in person_list:\n",
    "    print(person.이름, person.총점구하기(), person.평균구하기())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 이진석 100 90 80 270\n",
      "2 아이유 95 85 80 260\n",
      "3 공유 80 85 90 255\n"
     ]
    }
   ],
   "source": [
    "def sort_fn(person):\n",
    "    return person.총점구하기()\n",
    "\n",
    "sorted_person_list = sorted(person_list, key=sort_fn, reverse=True)\n",
    "for rank, person in enumerate(sorted_person_list[:3], 1):\n",
    "    print(rank, person.이름, person.국어, person.영어, person.수학, person.총점구하기())\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}