Day05PythonReview.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Data Type"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 자료형\n",
    "int_data = 4\n",
    "float_data = 3.14\n",
    "# 군집자료형\n",
    "str_data = 'I love Python' # str-원소의 수정, 삭제, 추가가 불가능\n",
    "list_data = [1,2,3,'가', '나']#list-원소의 수정, 삭제, 추가가 자유롭다\n",
    "tuple_data = (1,2,3,'가', '나')#tuple-원소의 수정, 삭제, 추가가 불가능\n",
    "dict_data={0:'가', 1:'나', 2:'다'}#dict-{key:value}, key가 인덱스역할을 한다\n",
    "set_data = {'a', 'b', 'c'}# set(집합)-인덱스가 없다, 중복데이터가 없다.\n",
    "# = 오른쪽의 값을 왼쪽에 넣는 다는 의미, 대입연산자\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n",
      "<class 'float'>\n",
      "<class 'str'>\n",
      "<class 'list'>\n",
      "<class 'tuple'>\n",
      "<class 'dict'>\n",
      "<class 'set'>\n"
     ]
    }
   ],
   "source": [
    "#데이터 타입 => type()메소드 사용\n",
    "print(type(int_data))\n",
    "print(type(float_data))\n",
    "print(type(str_data))\n",
    "print(type(list_data))\n",
    "print(type(tuple_data))\n",
    "print(type(dict_data))\n",
    "print(type(set_data))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, '가', '나']\n",
      "2\n",
      "가\n",
      "[1, 2, 3]\n",
      "['가', '나']\n"
     ]
    }
   ],
   "source": [
    "# 시퀀스형 데이터, str, list, tuple, set, dict: 원소가 여러개\n",
    "# 인덱싱, 슬라이싱이 가능하다\n",
    "# 인덱싱\n",
    "print(list_data)\n",
    "print(list_data[1])\n",
    "print(list_data[-2])\n",
    "# 슬라이싱=>':'사용\n",
    "print(list_data[1:4])# 2, 3, 가\n",
    "print(list_data[:3]) # 1, 2, 3\n",
    "print(list_data[-2:])# 가 나"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, '가', '나', '다']\n"
     ]
    }
   ],
   "source": [
    "#list에 원소 추가하기\n",
    "list_data.append('다')\n",
    "print(list_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "# 시퀀스 데이터의 원소갯수 구하기 => len()메소드\n",
    "print(len(list_data))\n",
    "# 특정 원소가 시퀀스 데이터에 포함되어 있는지 확인하기 => in 키워드\n",
    "print('가' in list_data)\n",
    "print('라' in list_data )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 'A', '나']\n"
     ]
    }
   ],
   "source": [
    "# 시퀀스형 데이터 값 수정하기\n",
    "list_data[3] = 'A'\n",
    "print(list_data)\n",
    "#append(), insert()..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1: 4, 2: 4, 3: 4, 5: 4, 6: 2, 9: 2, 8: 2, 7: 2, 4: 3}\n",
      "[9, 8, 7, 6, 5, 4, 3, 2, 1]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{1: 2, 3: 4}"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Dictionary추가 setdefault(), sorted()\n",
    "#다음의 리스트에서 각 정수가 몇 번 나왔는지 dict로 정리\n",
    "L=[1,1,1,2,2,3,3,3,5,5,6,6,9,9,8,8,7,7,5,2,1,4,5,4,2,3,4]\n",
    "D = {}\n",
    "for i in L:\n",
    "    D.setdefault(i,0)\n",
    "    D[i]+=1\n",
    "print(D)\n",
    "print(sorted(D, key=lambda x:x, reverse=True))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# if Statement"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "정수 x 입력30\n",
      "정수 y 입력20\n",
      "x와 y가 다릅니다\n"
     ]
    }
   ],
   "source": [
    "# x와 y가 같으면 'x와 y가 같습니다'\n",
    "# x와 y가 다르면 'x와 y가 다릅니다'\n",
    "x = int(input('정수 x 입력'))\n",
    "y = int(input('정수 y 입력'))\n",
    "if x==y: print('x와 y가 같습니다')\n",
    "else: print('x와 y가 다릅니다')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "정수 x 입력3\n",
      "정수 y 입력3\n",
      "x와 y가 같습니다\n"
     ]
    }
   ],
   "source": [
    "# x가 y보다 크면 'x가 y보다 큽니다'\n",
    "# x가 y보다 작으면 'x가 y보다 작습니다'\n",
    "# x와 y가 같으면 'x와 y가 같습니다'\n",
    "x = int(input('정수 x 입력'))\n",
    "y = int(input('정수 y 입력'))\n",
    "if x==y: print('x와 y가 같습니다')\n",
    "elif x>y: print('x가 y보다 큽니다')\n",
    "else: print('x가 y보다 작습니다.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "값 입력3\n",
      "값이 있습니다.\n"
     ]
    }
   ],
   "source": [
    "# 입력받은 값이 list_data에 있는지 확인하기\n",
    "\n",
    "# try문 사용\n",
    "data = input('값 입력')\n",
    "try:\n",
    "    if(data in list_data) or (int(data) in list_data):\n",
    "        print('값이 있습니다.')\n",
    "    else:\n",
    "        print('값이 없습니다.')\n",
    "except:\n",
    "    print('값이 없습니다.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "값 입력9\n",
      "값이 없습니다\n"
     ]
    }
   ],
   "source": [
    "# 입력받은 값이 list_data에 있는지 확인하기\n",
    "\n",
    "# for문 사용\n",
    "find = False\n",
    "data = input('값 입력')\n",
    "for i in list_data:\n",
    "    if str(i) == data:\n",
    "        print('값이 있습니다')\n",
    "        find = True\n",
    "        \n",
    "if not find:\n",
    "    print('값이 없습니다')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "점수입력70\n",
      "점수입력 성공\n",
      "C학점\n"
     ]
    }
   ],
   "source": [
    "# 학점을 입력받은 후 90이상이면 => A\n",
    "# 80이상이면 => B\n",
    "# 70이상이면 => C\n",
    "# 70미만이면 => D\n",
    "# 점수입력\n",
    "try:\n",
    "    score = int(input('점수입력'))\n",
    "except:\n",
    "    print('단위 빼고 숫자만 입력하세요')\n",
    "else:\n",
    "    print('점수입력 성공')\n",
    "    # 학점처리\n",
    "    if score >= 90:\n",
    "        print('A학점')\n",
    "    elif score >=80:\n",
    "        print('B학점')\n",
    "    elif score >= 70:\n",
    "        print('C학점')\n",
    "    else:\n",
    "        print('D학점')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 반복문<br/>\n",
    "1.for문<br/>\n",
    "for i in 시퀀스데이터: <br/>\n",
    "&nbsp;&nbsp;실행문<br/>\n",
    "2.while문<br/>\n",
    "while True/False:<br/>\n",
    "&nbsp;&nbsp;실행문<br/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### for Statement"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "A\n",
      "나\n"
     ]
    }
   ],
   "source": [
    "# list_data 원소 하나씩 출력\n",
    "for i in list_data:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 'A', '나']\n"
     ]
    }
   ],
   "source": [
    "# list_data의 원소를 하나씩 list_data_copy에 담기\n",
    "list_data_copy = []\n",
    "for i in list_data:\n",
    "    list_data_copy.append(i)\n",
    "print(list_data_copy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 <class 'int'>\n",
      "2 <class 'int'>\n",
      "3 <class 'int'>\n",
      "A <class 'str'>\n",
      "나 <class 'str'>\n"
     ]
    }
   ],
   "source": [
    "# list_data의 원소들의 데이터타입 출력하기\n",
    "for i in list_data:\n",
    "    print(i,type(i))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "# list_data에서 데이터타입이 'int'인 경우만 new_list에 담기\n",
    "new_list = []\n",
    "for i in list_data:\n",
    "    if type(i) == int:\n",
    "        new_list.append(i)\n",
    "print(new_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I\n",
      " \n",
      "l\n",
      "o\n",
      "v\n",
      "e\n",
      " \n",
      "P\n",
      "y\n",
      "t\n",
      "h\n",
      "o\n",
      "n\n",
      "++++++++\n",
      "I\n",
      "l\n",
      "o\n",
      "v\n",
      "e\n",
      "P\n",
      "y\n",
      "t\n",
      "h\n",
      "o\n",
      "n\n",
      "++++++++\n",
      "I love Python"
     ]
    }
   ],
   "source": [
    "# str_data에서 원소를 하나씩 출력하기\n",
    "for i in str_data:\n",
    "    print(i)\n",
    "# 공백빼고 출력하기:\n",
    "print('++++++++')\n",
    "for i in str_data:\n",
    "    if i ==' ':\n",
    "        continue\n",
    "    print(i)\n",
    "#가로로 출력하기\n",
    "print('++++++++')\n",
    "for i in str_data:\n",
    "    print(i, end='')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['I', ' ', 'L', 'O', 'V', 'E', ' ', 'P', 'Y', 'T', 'H', 'O', 'N']\n"
     ]
    }
   ],
   "source": [
    "# upper_list에 str_data원소 대문자로 변환해서 담기\n",
    "# x.upper()\n",
    "\n",
    "upper_list = []\n",
    "for i in str_data:\n",
    "    upper_list.append(i.upper())\n",
    "print(upper_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I\n",
      "o\n",
      "e\n",
      "o\n"
     ]
    }
   ],
   "source": [
    "# str_data에서 모음만 출력하기\n",
    "#aeiou\n",
    "for i in str_data:\n",
    "    if i not in 'aeiouAEIOU':\n",
    "        continue\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### while Statement "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "10\n",
      "11\n",
      "12\n",
      "13\n",
      "14\n",
      "15\n",
      "16\n",
      "17\n",
      "18\n",
      "19\n",
      "20\n",
      "21\n",
      "22\n",
      "23\n",
      "24\n",
      "25\n",
      "26\n",
      "27\n",
      "28\n",
      "29\n",
      "30\n"
     ]
    }
   ],
   "source": [
    "a = 1\n",
    "while True:\n",
    "    a += 1\n",
    "    print(a)\n",
    "    if a >= 30:\n",
    "        break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 연산"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 사칙연산자"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n",
      "-2\n",
      "8\n",
      "0.5\n",
      "0\n",
      "2\n",
      "16\n"
     ]
    }
   ],
   "source": [
    "# 정수/실수 연산 \n",
    "a = 2\n",
    "b = 4\n",
    "print(a+b)\n",
    "print(a-b)\n",
    "print(a*b)\n",
    "print(a/b)\n",
    "print(a//b)\n",
    "print(a%b)\n",
    "print(a**b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I love Pythonhello world\n",
      "I love Python hello world\n",
      "I love PythonI love Python\n"
     ]
    }
   ],
   "source": [
    "# 시퀀스데이터(원소를 여러 개 가진 데이터)의 연산: str, list, tuple, set, dict\n",
    "# +: 연결\n",
    "str_data1 = 'hello world'\n",
    "print(str_data+str_data1)\n",
    "print(str_data+' '+str_data1)\n",
    "# *: 반복\n",
    "print(str_data*2)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 'A', '나', [6, 7, 8], '마']\n",
      "[1, 2, 3, 'A', '나', 1, 2, 3, 'A', '나']\n"
     ]
    }
   ],
   "source": [
    "# 시퀀스데이터(원소를 여러 개 가진 데이터)의 연산: str, list, tuple, set, dict\n",
    "# +: 연결\n",
    "list_data1 = [[6,7,8], '마']\n",
    "print(list_data+list_data1)\n",
    "# *: 반복\n",
    "print(list_data*2)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 관계 연산자\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "False\n",
      "True\n",
      "True\n",
      "False\n",
      "True\n",
      "++++++++\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# == 같다, != 같지 않다, > 크다, < 작다, >= 크거나 같다, <= 작거나 같다\n",
    "x = 1\n",
    "y = 2\n",
    "str1 = 'abc'\n",
    "str2 = 'python'\n",
    "print(x==y)\n",
    "print(x>y)\n",
    "print(x<y)\n",
    "print(x!=y)\n",
    "print(x>=y)\n",
    "print(x<=y)\n",
    "print('++++++++')\n",
    "print(str1==str2)\n",
    "print(str1!=str2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "a=True\n",
    "b=False\n",
    "\n",
    "print(a and b) # 하나라도 False면 False\n",
    "print(a or b) # 하나라도 True면 True\n",
    "print(not a) # True/False 반전\n",
    "print(not b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Sequence Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Time\n",
      "is\n",
      "money\n",
      "money\n",
      "[2, 3]\n",
      "[3]\n",
      "[1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "strdata = 'Time is money!'\n",
    "listdata = [1,2,[1,2,3]]\n",
    "\n",
    "# Time을 출력\n",
    "print(strdata[:4])\n",
    "# is를 출력\n",
    "print(strdata[5:7])\n",
    "# money를 출력\n",
    "print(strdata[8:-1])\n",
    "print(strdata[-6:-1])\n",
    "# [2,3]을 출력\n",
    "print(listdata[-1][1:])\n",
    "# [3]을 출력\n",
    "print(listdata[-1][-1:])\n",
    "# [1,2,3]을 출력\n",
    "print(listdata[-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 함수"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6.2\n"
     ]
    }
   ],
   "source": [
    "# 함수의 정의:\n",
    "# def 함수명(파라미터):\n",
    "def add_number(n1, n2):\n",
    "    result = n1+n2\n",
    "    return result\n",
    "# 함수의 실행\n",
    "# 함수명(매개변수)\n",
    "print(add_number(3.5,2.7))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "hello python\n",
      "3 apples\n"
     ]
    }
   ],
   "source": [
    "#\n",
    "def add_text(t1, t2):\n",
    "    if type(t1) == str and type(t2) == str:\n",
    "        result = t1 + ' ' + t2\n",
    "    elif type(t1) == str or type(t2) == str:\n",
    "        result = str(t1)+' '+str(t2)\n",
    "    else:\n",
    "        result = t1 + t2\n",
    "    return result\n",
    "# main\n",
    "print(add_text(2,3))\n",
    "print(add_text('hello', 'python'))\n",
    "print(add_text(3,'apples'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12\n",
      "문자열를 입력하세요: assdd\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "# 문자열을 입력받아서 문자열의 길이를 리턴하는 함수를 만드시오\n",
    "def string_length(string):\n",
    "    count = 0\n",
    "    for i in string:\n",
    "        count += 1\n",
    "    return count\n",
    "def str_length():\n",
    "    string = input('문자열를 입력하세요: ')\n",
    "    count = 0\n",
    "    for i in string:\n",
    "        count += 1\n",
    "    return count\n",
    "# main\n",
    "print(string_length('hello python'))\n",
    "print(str_length())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(19, 6.333333333333333)\n",
      "19\n",
      "6.333333333333333\n",
      "정수 1 입력2\n",
      "정수 2 입력8\n",
      "정수 3 입력9\n",
      "19\n",
      "정수 1 입력2\n",
      "정수 2 입력8\n",
      "정수 3 입력9\n",
      "6.333333333333333\n"
     ]
    }
   ],
   "source": [
    "# 임의의 정수 3개를 받은 후 합과 평균을 리턴하는 함수\n",
    "\n",
    "def threenum(n1,n2,n3):\n",
    "    return(n1+n2+n3, (n1+n2+n3)/3)\n",
    "def threenum1(n1,n2,n3, m):\n",
    "    if m == '합':\n",
    "        return n1+n2+n3\n",
    "    elif m =='평':\n",
    "        return((n1+n2+n3)/3)\n",
    "def threeinputnum(m):\n",
    "    n1 = int(input('정수 1 입력'))\n",
    "    n2 = int(input('정수 2 입력'))\n",
    "    n3 = int(input('정수 3 입력'))\n",
    "    if m == '합':\n",
    "        return n1+n2+n3\n",
    "    elif m =='평':\n",
    "        return((n1+n2+n3)/3)\n",
    "# main\n",
    "print(threenum(2,8,9))\n",
    "print(threenum1(2,8,9,'합'))\n",
    "print(threenum1(2,8,9,'평'))\n",
    "print(threeinputnum('합'))\n",
    "print(threeinputnum('평'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "정수를 입력하세요: -9\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "#임의의 정수를 입력받아 절대값을 리턴하는 함수\n",
    "def absval(n):\n",
    "    if n >= 0:\n",
    "        return n\n",
    "    else:\n",
    "        return (-1)*n\n",
    "def inputabs():\n",
    "    n = int(input('정수를 입력하세요: '))\n",
    "    return absval(n)\n",
    "# main\n",
    "print(absval(-3))\n",
    "print(inputabs())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "woosubgo님 환영합니다!!\n",
      "이메일을 입력하세요woosubgo@daum.net\n",
      "woosubgo님 환영합니다!!\n"
     ]
    }
   ],
   "source": [
    "# 이메일을 입력받고 id를 뽑아서 '아이디님 환영합니다' 출력하는 함수\n",
    "def hiID(email):\n",
    "    id = email.split('@')[0]\n",
    "    print('{}님 환영합니다!!'.format(id))\n",
    "def inputemail():\n",
    "    email = input('이메일을 입력하세요')\n",
    "    hiID(email)\n",
    "# main\n",
    "hiID('woosubgo@naver.com')\n",
    "inputemail()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "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.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}