Source/pythonSource/Basic/exam1.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "327c097c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "# 변수 : 프로그램 내부에서 값을 담아놓기 위한 공간(이름 사용)\n",
    "# 정수형\n",
    "\n",
    "a = 10\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4929f0bd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, World!\n"
     ]
    }
   ],
   "source": [
    "print(\"Hello, World!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "40c1b43b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "b = [1, 2, 3, 4, 5]\n",
    "print(b)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d5b219e7",
   "metadata": {},
   "source": [
    "- control + enter = 현재 셀만 실행\n",
    "- shift + enter = 현재 셀 실행 + 아래 빈 셀 추가"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c621c863",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = True\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6af4a82e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "14\n",
      "6\n",
      "40\n",
      "2.5\n",
      "2\n",
      "2\n",
      "10000\n"
     ]
    }
   ],
   "source": [
    "a, b = 10, 4\n",
    "a\n",
    "b\n",
    "# 사칙연산 (+, -, *, /, //, %)\n",
    "print(a + b)\n",
    "print(a - b)\n",
    "print(a * b)\n",
    "print(a / b) # 몫과 나머지\n",
    "print(a // b) # 몫만 남김\n",
    "print(a % b) # 나머지 연산자, a를 b로 나눈 나머지를 구하는 연산자\n",
    "print(a ** b) # a 의 b 제곱"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0d6bd739",
   "metadata": {},
   "source": [
    "### 문자열 자료형\n",
    "- 홑따옴표('), 쌍따옴표(\") 사용\n",
    "- 홑따옴표('''), 쌍따옴표(\"\"\") 사용 => multiline "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "97d1e1ad",
   "metadata": {},
   "outputs": [],
   "source": [
    "msg = 'Hello, World!'\n",
    "msg = \"Hello, World!\"\n",
    "msg = 'Hello, \"World!\"'\n",
    "msg = \"Hello, 'World!'\"\n",
    "msg = '''Hello\n",
    "        World!'''\n",
    "msg = \"\"\"Hello, \n",
    "        World!\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "925a6c89",
   "metadata": {},
   "outputs": [],
   "source": [
    "food = \"Python's favorite food is perl\"\n",
    "food"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "9c73bd1b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Life is too shortyou need python'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "multiline = \"Life is too short\" \\\n",
    "\"you need python\"\n",
    "multiline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0900fed7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Life is too short \n",
      "you need python\n",
      "\n"
     ]
    }
   ],
   "source": [
    "multiline = '''\n",
    "Life is too short \n",
    "you need python\n",
    "'''\n",
    "print(multiline)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e7228650",
   "metadata": {},
   "source": [
    "# 문자열 연산"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cb1fc46d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Python is fun!'"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# + : 연결\n",
    "\n",
    "head = \"Python\"\n",
    "tail = \" is fun!\"\n",
    "head + tail"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5259347d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'PythonPython'"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# * : 반복\n",
    "head * 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "faad4d62",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# len() 함수는 문자열의 길이를 구하는 함수입니다.\n",
    "len(head)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "76aae57e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# len() : 길이 구하기\n",
    "\n",
    "len(head)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "da78c7ec",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'s'"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 문자열 인덱싱과 슬라이싱\n",
    "a = \"Life is too short, you need Python\"\n",
    "a[0] # 문자열의 첫 번째 문자\n",
    "a[12] # 문자열의 13번째 문자\n",
    "a[-1] # 문자열의 마지막 문자\n",
    "a[-2] # 문자열의 끝에서 두 번째 문자\n",
    "a[0:4] # 문자열의 첫 번째 문자부터 네 번째 문자까지 (0\n",
    "a[19:] # 문자열의 20번째 문자부터 끝까지\n",
    "a[:17] # 문자열의 처음부터 17번째 문자까지 (0~16)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b34f4f42",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Life is too short, you need Python\n",
      "Life is too short, you need Pytho\n",
      "short\n",
      "on\n"
     ]
    }
   ],
   "source": [
    "# 슬라이싱 : 인덱싱을 이용해 문자열 분리\n",
    "print(a[0:]) # 0 부터 끝까지\n",
    "print(a[0:-1]) # 0 부터 -1까지(마지막 인덱싱 포함하지 않음)\n",
    "print(a[12:17]) # 12 부터 17까지(마지막 인덱싱 포함하지 않음)\n",
    "print(a[-2:]) # -2 부터 끝까지\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "baa487b9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20260512\n",
      "Rainy\n"
     ]
    }
   ],
   "source": [
    "a = '20260512Rainy'\n",
    "\n",
    "# 날짜\n",
    "print(a[0:8])\n",
    "# 날씨\n",
    "print(a[8:15])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c10a8379",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "현재 온도는 20 도입니다.\n",
      "현재 온도는 20도 입니다.\n",
      "현재 온도는 20도 입니다.\n",
      "현재 온도는 20도 입니다.\n"
     ]
    }
   ],
   "source": [
    "a = 20\n",
    "#print(\"현재 온도는 \" + a + \"도입니다.\") # TypeError: can only concatenate str (not \"int\") to str\n",
    "print(\"현재 온도는\",a, \"도입니다.\") # str()\n",
    "print(\"현재 온도는 %d도 입니다.\" % a) # str() 함수를 이용하여 정수 a를 문자열로 변환하여 출력\n",
    "print(\"현재 온도는 {}도 입니다.\".format(a)) # str() 함수를 이용하여 정수 a를 문자열로 변환하여 출력\n",
    "print(f\"현재 온도는 {a}도 입니다.\") # str() 함수를 이용하여 정수 a를 문자열로 변환하여 출력\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bca24b2c",
   "metadata": {},
   "source": [
    "### 함수 : 이미 기능을 가지고 있음\n",
    "- len() : 문자열의 길이를 구하는 함수\n",
    "- str() : 정수나 실수를 문자열로 변환하는 함수\n",
    "- int() : 문자열을 정수로 변환하는 함수\n",
    "- float() : 문자열을 실수로 변환하는 함수\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a2a40240",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = 'habby'\n",
    "a.count('b')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "09cdebd0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "# find() : 문자열에서 특정 문자열이 처음으로 등장하는 위치를 반환하는 함수입니다. 만약 찾는 문자열이 존재하지 않으면 -1을 반환합니다.\n",
    "# a.find('b')\n",
    "print(a.find('b'))\n",
    "print(a.index('b')) # find()와 index()는 거의 동일하지만, index()는 찾는 문자열이 존재하지 않을 때 ValueError 예외를 발생시킵니다. find()는 -1을 반환하는 반면, index()는 예외를 발생시키므로, 찾는 문자열이 반드시 존재해야 하는 경우에는 index()를 사용하는 것이 좋습니다.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2264a946",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "apple,banana,cherry\n"
     ]
    }
   ],
   "source": [
    "#join() : 문자열을 연결하는 함수입니다. join() 함수는 문자열을 연결할 때 사용되며, 연결할 문자열들을 리스트나 튜플 등의 시퀀스 자료형으로 전달받습니다. join() 함수는 시퀀스 자료형의 각 요소를 문자열로 변환한 후, 지정된 구분자(separator)를 사용하여 연결된 문자열을 반환합니다. 예를 들어, \",\".join([\"apple\", \"banana\", \"cherry\"])는 \"apple,banana,cherry\"를 반환합니다. join() 함수는 문자열을 연결할 때 효율적이며, 여러 개의 문자열을 한 번에 연결할 때 유용하게 사용됩니다.\n",
    "print(\",\".join([\"apple\", \"banana\", \"cherry\"]))\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3fc4ce33",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "HELLO\n",
      "hello\n"
     ]
    }
   ],
   "source": [
    "# 대소문자 변경 : upper() : 문자열을 모두 대문자로 변환하는 함수입니다. lower() : 문자열을 모두 소문자로 변환하는 함수입니다. capitalize() : 문자열의 첫 번째 문자를 대문자로 변환하고 나머지 문자를 소문자로 변환하는 함수입니다. title() : 문자열의 각 단어의 첫 번째 문자를 대문자로 변환하고 나머지 문자를 소문자로 변환하는 함수입니다.\n",
    "print(\"hello\".upper()) # \"HELLO\"\n",
    "print(\"HELLO\".lower()) # \"hello\"\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "04065ada",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   Hello, World!   \n",
      "Hello, World!\n",
      "Hello, World!   \n",
      "   Hello, World!\n"
     ]
    }
   ],
   "source": [
    "# 공백 제거 : strip() : 문자열의 양쪽 끝에 있는 공백을 제거하는 함수입니다. lstrip() : 문자열의 왼쪽 끝에 있는 공백을 제거하는 함수입니다. rstrip() : 문자열의 오른쪽 끝에 있는 공백을 제거하는 함수입니다.\n",
    "a = \"   Hello, World!   \"\n",
    "print(a)\n",
    "print(a.strip()) # \"Hello, World!\"\n",
    "print(a.lstrip()) # \"Hello, World!   \"\n",
    "print(a.rstrip()) # \"   Hello, World!\"\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "840303d9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Life is too short\n"
     ]
    }
   ],
   "source": [
    "# replace() : 문자열에서 특정 문자열을 다른 문자열로 대체하는 함수입니다. replace() 함수는 원본 문자열에서 지정된 문자열을 찾아서 새로운 문자열로 대체한 결과를 반환합니다. 예를 들어, \"Hello, World!\".replace(\"World\", \"Python\")는 \"Hello, Python!\"을 반환합니다. replace() 함수는 원본 문자열을 변경하지 않고, 대체된 새로운 문자열을 반환하므로, 원본 문자열은 그대로 유지됩니다.\n",
    "a = \"Life is too short\" \n",
    "a.replace(\"Life\", \"Your leg\")\n",
    "\n",
    "print(a) # 원본 문자열은 변경되지 않음"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7114f4ab",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['a,', 'b,', 'c,', 'd,', 'e']"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# split() : 문자열을 특정 구분자(separator)를 기준으로 나누어 리스트로 반환하는 함수입니다. split() 함수는 문자열을 나눌 때 사용되며, 구분자를 지정하지 않으면 공백을 기준으로 문자열을 나눕니다. 예를 들어, \"Hello, World!\".split(\",\")는 [\"Hello\", \" World!\"]를 반환합니다. split() 함수는 문자열을 나눌 때 효율적이며, 여러 개의 문자열을 한 번에 나눌 때 유용하게 사용됩니다.\n",
    "\n",
    "a.split() # 공백을 기준으로 문자열을 나눔\n",
    "\n",
    "b = \"a, b, c, d, e\"\n",
    "b.split() # 리스트는 split() 함수를 사용할 수 없습니다. split() 함수는 문자열에서만 사용할 수 있습니다. 리스트를 문자열로 변환한 후에 split() 함수를 사용할 수 있습니다. 예를 들어, \",\".join(b).split(\",\")는 ['1', '2', '3', '4', '5']를 반환합니다.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c3b8118c",
   "metadata": {},
   "source": [
    "# list 자료형\n",
    "- [1, 3, 5, 7] \n",
    "- 인덱스 번호를 가지고 있어 슬라이싱이 가능"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "795cb215",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 리스트 생성\n",
    "a = []\n",
    "b = [ 1, 3, 5, 7, 9 ]\n",
    "c = list()\n",
    "d = ['Life', 'is', 'too', 'short']\n",
    "f = [ 1, 2, 'too', 'short']\n",
    "g = [1, 2, ['life', 'is' ]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "caf4c5ca",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "too\n",
      "['life', 'is']\n",
      "['life', 'is']\n"
     ]
    }
   ],
   "source": [
    "# 인덱싱\n",
    "print(b[1])\n",
    "print(d[2])\n",
    "print(g[2])\n",
    "print(g[-1])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "379aa915",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# + 연결\n",
    "a + b\n",
    "b + d\n",
    "\n",
    "# * 반복\n",
    "b * 2\n",
    "\n",
    "# 리스트 길이 구하기\n",
    "len(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7e58ae86",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[]\n",
      "[]\n"
     ]
    }
   ],
   "source": [
    "print(a)\n",
    "print(c)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d5d35993",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['hello', 'world', 'hello', 'world']"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# append() : 리스트에 요소를 추가하는 함수입니다. append() 함수는 리스트의 끝에 새로운 요소를 추가합니다. 예를 들어, a.append(10)은 리스트 a의 끝에 10을 추가합니다. append() 함수는 원본 리스트를 변경하며, 반환값은 없습니다.\n",
    "a.append(\"hello\")\n",
    "a.append(\"world\")\n",
    "a\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "99d7f463",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[['hello', 'bye'], ['hello', 'bye']]"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c.append(['hello', 'bye'])\n",
    "c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "71e05f8d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 정렬"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b2e5f9db",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4]"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 정렬 : sort() 함수는 리스트를 정렬하는 함수입니다. sort() 함수는 원본 리스트를 변경하며, 반환값은 없습니다. sort() 함수는 기본적으로 오름차순으로 정렬하지만, reverse=True 매개변수를 사용하여 내림차순으로 정렬할 수도 있습니다.\n",
    "\n",
    "a = [1, 4, 2, 3]\n",
    "a.sort() # 리스트 a를 오름차순으로 정렬합니다. sort() 함수는 원본 리스트를 변경하며, 반환값은 없습니다.\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8d2c7520",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[4, 3, 2, 1]"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.sort(reverse=True) # 리스트 a를 내림차순으로 정렬합니다. sort() 함수는 원본 리스트를 변경하며, 반환값은 없습니다.\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b02ccd37",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# index()\n",
    "a.index(2) # 리스트 a에서 값 2가 처음으로 등장하는 인덱스를 반환합니다. 만약 찾는 값이 존재하지 않으면 ValueError 예외를 발생시킵니다. index() 함수는 리스트에서 특정 값을 찾을 때 유용하게 사용됩니다.\n",
    "a.fin"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "30d312fe",
   "metadata": {},
   "outputs": [],
   "source": [
    "# append() : 리스트에 요소를 추가하는 함수입니다. append() 함수는 리스트의 끝에 새로운 요소를 추가합니다. 예를 들어, a.append(10)은 리스트 a의 끝에 10을 추가합니다. append() 함수는 원본 리스트를 변경하며, 반환값은 없습니다.\n",
    "# insert() : 리스트의 특정 위치에 요소를 추가하는 함수입니다. insert() 함수는 리스트의 특정 인덱스에 새로운 요소를 삽입합니다. 예를 들어, a.insert(1, 10)은 리스트 a의 인덱스 1에 10을 삽입합니다. insert() 함수는 원본 리스트를 변경하며, 반환값은 없습니다.  \n",
    "b.insert(1, 10) # 리스트 b의 인덱스 1에 10을 삽입합니다. insert() 함수는 원본 리스트를 변경하며, 반환값은 없습니다.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "112b51a1",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 제거\n",
    "b.remove(5) # 리스트 b에서 값 10을 제거합니다. remove() 함수는 리스트에서 첫 번째로 등장하는 지정된 값을 제거하며, 원본 리스트를 변경합니다. 만약 찾는 값이 존재하지 않으면 ValueError 예외를 발생시킵니다. remove() 함수는 리스트에서 특정 값을 제거할 때 유용하게 사용됩니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "08f068a4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b.pop()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d80c64e6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 10, 3, 5, 7]"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8d47b622",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 10, 5, 7]"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 2번 idx 요소 제거\n",
    "b.pop(2)\n",
    "b\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8acdac0e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# count() : 리스트에서 특정 값이 몇 번 등장하는지 세는 함수입니다. count() 함수는 리스트에서 지정된 값이 몇 번 나타나는지를 반환합니다. 예를 들어, b.count(1)은 리스트 b에서 값 1이 몇 번 등장하는지를 반환합니다. count() 함수는 리스트에서 특정 값의 빈도를 확인할 때 유용하게 사용됩니다.\n",
    "b.count(1)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0f898293",
   "metadata": {},
   "source": [
    "### 튜플\n",
    "- ()\n",
    "- 튜플은 리스트와 유사하나, 요소값을 변경할 수 없다. ( 리스트는 요소값 생성, 수정 , 삭제 가능)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3ecdc347",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 생성\n",
    "t1 = ()\n",
    "t2 = (1, )\n",
    "t3 = 1, 2, 3\n",
    "t4 = (1, 2, 3)\n",
    "t5 = ('a', 'b', ('ab', 'cd'))\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "028f2ca3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 1, 2, 3)"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t2 + t3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "24aeeb93",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[88, 10, 5, 7]\n",
      "(1, 2, 3)\n"
     ]
    }
   ],
   "source": [
    "# 리스트 요소 수정\n",
    "b[0] = 88\n",
    "print(b)\n",
    "\n",
    "# 튜플 요소 수정 불가\n",
    "# t4[0] = 88 # 튜플은 요소를 수정할 수 없습니다. 튜플은 불변(immutable)한 자료형이므로, 한 번 생성된 튜플의 요소는 변경할 수 없습니다. 따라서 t4[0] = 88과 같은 코드는 TypeError 예외를 발생시킵니다. 튜플의 요소를 변경하려면 새로운 튜플을 생성해야 합니다. 예를 들어, t4 = (88,) + t4[1:]와 같이 새로운 튜플을 생성하여 요소를 변경할 수 있습니다.\n",
    "print(t4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "06ef8c0b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 2)"
      ]
     },
     "execution_count": 126,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t4[0:2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1cbca157",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(t4)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c37a5c87",
   "metadata": {},
   "source": [
    "### 딕셔너리 자료형\n",
    "- {key1:value1, key2:value2}\n",
    "- key 값 중복 불가\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "db7a6a5b",
   "metadata": {},
   "outputs": [],
   "source": [
    "dict1 = {'name': 'Alice', 'age': 30, 'city': 'New York'}\n",
    "dict2 = {1:'kim', 2:22, 3:\"part\"}\n",
    "dict3 = {\"arr\": [1, 2, 3, 4, 5]}\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cd658f9f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Alice\n",
      "Alice\n",
      "part\n"
     ]
    }
   ],
   "source": [
    "# kim 출력\n",
    "print(dict1[\"name\"])\n",
    "print(dict1.get(\"name\")) # 추천\n",
    "print(dict2.get(3))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2abdb89f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'name': 'Alice', 'city': 'New York'}"
      ]
     },
     "execution_count": 135,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "del dict1['age'] # 딕셔너리 dict1에서 키 'age'와 해당 값을 삭제합니다. del 키워드는 딕셔너리에서 특정 키를 제거하는 데 사용됩니다. del dict1['age']는 dict1에서 'age' 키와 해당 값을 삭제하며, 원본 딕셔너리를 변경합니다. 만약 삭제하려는 키가 존재하지 않으면 KeyError 예외를 발생시킵니다. del 키워드는 딕셔너리에서 특정 키를 제거할 때 유용하게 사용됩니다.\n",
    "dict1\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "861fe8a2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'name': 'Alice', 'city': 'New York', 'birth': '1990-01-01'}"
      ]
     },
     "execution_count": 137,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 추가 birth : '1990-01-01'\n",
    "dict1['birth'] = '1990-01-01'\n",
    "dict1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7376720f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'name': 'Alice',\n",
       " 'city': 'New York',\n",
       " 'birth': '1990-01-01',\n",
       " 'rank': [15, 17, 19]}"
      ]
     },
     "execution_count": 146,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# rank = [15, 17, ,19]\n",
    "dict1['rank'] = [15, 17, 19]\n",
    "dict1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8fd35f51",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_keys(['name', 'city', 'birth', 'rank'])\n",
      "dict_values(['Alice', 'New York', '1990-01-01', [15, 17, 19]])\n",
      "dict_items([('name', 'Alice'), ('city', 'New York'), ('birth', '1990-01-01'), ('rank', [15, 17, 19])])\n"
     ]
    }
   ],
   "source": [
    "# 키 값만 가져오기\n",
    "print(dict1.keys()) # dict1의 모든 키를 반환하는 함수입니다. keys() 함수는 딕셔너리에서 모든 키를 반환하는 뷰 객체를 반환합니다. 예를 들어, dict1.keys()는 dict1의 모든 키를 반환합니다. keys() 함수는 딕셔너리에서 키를 확인하거나 반복할 때 유용하게 사용됩니다.\n",
    "print(dict1.values()) # dict1의 모든 값을 반환하는 함수입니다. values() 함수\n",
    "print(dict1.items()) # dict1의 모든 키-값 쌍을 반환하는 함수입니다. items() 함수는 딕셔너리에서 모든 키-값 쌍을 반환하는 뷰 객체를 반환합니다. 예를 들어, dict1.items()는 dict1의 모든 키-값 쌍을 반환합니다. items() 함수는 딕셔너리에서 키와 값을 동시에 확인하거나 반복할 때 유용하게 사용됩니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ef7f8e27",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# in\n",
    "print('사과' in ['사과', '바나나', '체리']) # 리스트에서 '사과'가 존재하는지 확인합니다. in 연산자는 시퀀스 자료형에서 특정 요소가 존재하는지 여부를 확인하는 데 사용됩니다. 예를 들어, '사과' in ['사과', '바나나', '체리']는 True를 반환합니다. in 연산자는 리스트, 튜플, 문자열 등 다양한 시퀀스 자료형에서 사용할 수 있습니다.\n",
    "# 키가 포함되어 있는가?\n",
    "print('사과' in dict1) # 딕셔너리 dict1에서 '사과'라는 키가 존재하는지 확인합니다. in 연산자는 딕셔너리에서 특정 키가 존재하는지 여부를 확인하는 데 사용됩니다. 예를 들어, '사과' in dict1은 dict1에 '사과'라는 키가 존재하면 True를 반환하고, 그렇지 않으면 False를 반환합니다. in 연산자는 딕셔너리에서 키의 존재 여부를 확인할 때 유용하게 사용됩니다.\n",
    "print('name' in dict1) # 딕셔너리 dict1에서 'name'이라는 키가 존재하는지 확인합니다. in 연산자는 딕셔너리에서 특정 키가 존재하는지 여부를 확인하는 데 사용됩니다. 예를 들어, 'name' in dict1은 dict1에 'name'이라는 키가 존재하면 True를 반환하고, 그렇지 않으면 False를 반환합니다. in 연산자는 딕셔너리에서 키의 존재 여부를 확인할 때 유용하게 사용됩니다.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c5536c53",
   "metadata": {
    "notebookRunGroups": {
     "groupValue": "2"
    }
   },
   "source": [
    "### 조건문\n",
    "- 조건에 맞는 상황을 판단한 후 수행하는 것\n",
    "- ex) 현재 변수에 값이 5라면, dict1 키가 name이 포힘돠어 있다면\n",
    "\n",
    "``` if 조건문: ```\n",
    "        ``` 조건이 참일때 수행할 문장```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a87ee145",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "66d9e5ac",
   "metadata": {},
   "outputs": [],
   "source": [
    "# money 10,000 이상을 가지고 있다면 택시 타기\n",
    "money = 5000\n",
    "\n",
    "if money > 10000:\n",
    "    print(\"택시타기\")\n",
    "    \n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ad742983",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "걸어가기\n"
     ]
    }
   ],
   "source": [
    "# money 10,000 이상을 가지고 있다면 택시 타기\n",
    "money = 5000\n",
    "\n",
    "if money >= 10000:\n",
    "    print(\"택시타기\")\n",
    "else:\n",
    "    print(\"걸어가기\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "58f6afd8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "B\n"
     ]
    }
   ],
   "source": [
    "# >=90, A / >=80, B / >=70 / c, d\n",
    "# if 조건 :\n",
    "#     pass\n",
    "# elif 조건 :\n",
    "#     pass\n",
    "# elif 조건 :\n",
    "#     pass\n",
    "# else :\n",
    "#     pass\n",
    "    \n",
    "su = 88\n",
    "\n",
    "if su >= 90:\n",
    "    print(\"A\")\n",
    "elif su >= 80:\n",
    "    print(\"B\")\n",
    "elif su >= 70:\n",
    "    print(\"C\")\n",
    "else:\n",
    "    print(\"D\")\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d3890a4c",
   "metadata": {},
   "outputs": [],
   "source": [
    "su = int(input(\"점수를 입력하세요 : \"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "03c3042e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "C\n"
     ]
    }
   ],
   "source": [
    "su = int(su) # 입력받은 문자열을 정수로 변환합니다. input() 함수는 사용자로부터 입력을 받을 때 문자열 형태로 반환하므로, su = int(su)를 사용하여 입력받은 문자열을 정수로 변환해야 합니다. 이렇게 하면 su 변수에 정수 값이 저장되어 이후의 조건문에서 올바르게 비교할 수 있습니다.\n",
    "\n",
    "\n",
    "if su >= 90:\n",
    "    print(\"A\")\n",
    "elif su >= 80:\n",
    "    print(\"B\")\n",
    "elif su >= 70:\n",
    "    print(\"C\")\n",
    "else:\n",
    "    print(\"D\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "af6f7357",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'str'>\n",
      "<class 'int'>\n",
      "<class 'int'>\n"
     ]
    }
   ],
   "source": [
    "a = '99'\n",
    "b = 98\n",
    "# print(a >= 90)\n",
    "print(type(a))\n",
    "print(type(b))\n",
    "\n",
    "# a를 int 타입 변경\n",
    "a = int(a)\n",
    "print(type(a))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ff6d1883",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "합격\n"
     ]
    }
   ],
   "source": [
    "su = int(input(\"점수를 입력하세요 : \"))\n",
    "\n",
    "if su >= 90:\n",
    "    z = \"A\"\n",
    "elif su >= 80:\n",
    "    z = \"B\"\n",
    "elif su >= 70:\n",
    "    z = \"C\"\n",
    "else:\n",
    "    z = \"D\"\n",
    "\n",
    "if(su >= 90 and z == \"A\"):\n",
    "    print(\"합격\")\n",
    "else:    \n",
    "    print(\"불합격\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a18e0c62",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "사과\n"
     ]
    }
   ],
   "source": [
    "# 키가 포함되어 있는가?\n",
    "print('사과')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c6c03f4e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "num1 = 25\n",
    "print(num1 // 2)\n",
    "print(num1 % 2) # 나머지 연산자, a를 b로 나눈 나머지를 구하는 연산자\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d3e98df6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "홀수입니다.\n"
     ]
    }
   ],
   "source": [
    "# 숫자를 입력바등ㄴ 후 홀, 짝 구분\n",
    "\n",
    "# 비교 연산자\n",
    "# == : 두 값이 같은지 비교하는 연산자입니다. 예를 들어, 5 == 5는 True를 반환하고, 5 == 4는 False를 반환합니다. == 연산자는 값의 동등성을 비교할 때 사용됩니다.\n",
    "# != : 두 값이 다른지 비교하는 연산자입니다. 예를 들어, 5 != 4는 True를 반환하고, 5 != 5는 False를 반환합니다. != 연산자는 값의 부등성을 비교할 때 사용됩니다.\n",
    "\n",
    "\n",
    "num = int(input(\"숫자를 입력하세요 : \"))\n",
    "\n",
    "if num % 2 == 0:\n",
    "    print(\"짝수입니다.\")\n",
    "else:\n",
    "    print(\"홀수입니다.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "414aa9d0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "success\n"
     ]
    }
   ],
   "source": [
    "# score가 60 이상이면 success / failure\n",
    "score = int(input(\"점수를 입력하세요 : \"))\n",
    "\n",
    "if score >= 60:\n",
    "    print(\"success\")\n",
    "else:\n",
    "    print(\"failure\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "746a8f64",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Failure\n"
     ]
    }
   ],
   "source": [
    "score = int(input(\"점수를 입력하세요 : \"))\n",
    "\n",
    "msg = \"Success\" if score >= 60 else \"Failure\"\n",
    "print(msg)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "637f3673",
   "metadata": {},
   "source": [
    "- while 문\n",
    "\n",
    "while 조건:\n",
    "    반복해서 해야 할 일들\n",
    "\n",
    "- for 문\n",
    "\n",
    "for 변수 in 리스트 (또는 튜플, 문자열, 딕셔너리..):\n",
    "    반복해서 해야할 일들"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b7c22708",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5]\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "# 리스트 출력\n",
    "list1 = [1, 2, 3, 4, 5]\n",
    "print(list1)\n",
    "\n",
    "for i in list1:\n",
    "    print(i)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c5f8a7f2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "t1 = (1, 2, 3)\n",
    "for i in t1:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "78a0326b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "7\n",
      "11\n"
     ]
    }
   ],
   "source": [
    "list1 = [(1, 2), (3, 4), (5, 6)]\n",
    "for first, last in list1:\n",
    "    print(first + last)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f01cfe76",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\t2\t3\t4\t5\t6\t7\t8\t9\t10\t"
     ]
    }
   ],
   "source": [
    "# 1 ~ 10 까지 cnffur\n",
    "i = 1\n",
    "\n",
    "while i <= 10:\n",
    "    print(i, end='\\t')\n",
    "    i += 1\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "95be308e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "총합 : 790, 평균 : 79.0\n"
     ]
    }
   ],
   "source": [
    "# 총 10명의 학생 점수\n",
    "classA = [70, 60, 55, 75, 95, 90, 80, 80, 85, 100]\n",
    "\n",
    "# 총합과 평균 구하기\n",
    "\n",
    "total = 0\n",
    "for score in classA:\n",
    "    total += score\n",
    "    \n",
    "avg = total / len(classA)\n",
    "\n",
    "print(f\"총합 : {total}, 평균 : {avg}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cb7b38c2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "79.0"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 평균\n",
    "sum(classA) / len(classA)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e77a0e61",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "range(1, 10, 2)"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "range(5) # 0 ~ 4까지의 정수 생성\n",
    "range(1, 6) # 1 ~ 5까지의 정수 생성\n",
    "range(1, 10, 2) # 1 ~ 9까지의 정수 생성, 2씩 증가\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d4107acf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "10\n",
      "1\n",
      "3\n",
      "5\n",
      "7\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "\n",
    "for i in range(5):\n",
    "    print(i)\n",
    "    \n",
    "    \n",
    "for i in range(1, 11):\n",
    "    print(i)\n",
    "\n",
    "for i in range(1, 11, 2):\n",
    "    print(i)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a50256f9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dreams\n",
      "d\n",
      "d\n",
      "r\n",
      "e\n",
      "a\n",
      "m\n",
      "s\n"
     ]
    }
   ],
   "source": [
    "msg = \"dreams\"\n",
    "print(msg)\n",
    "\n",
    "print(msg[0])\n",
    "\n",
    "for s in msg:\n",
    "    print(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0a8afbe7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'a': 1, 'b': 80, 'c': 70}\n",
      "a 1\n",
      "b 80\n",
      "c 70\n"
     ]
    }
   ],
   "source": [
    "dict1 = { 'a': 1, 'b': 80, 'c': 70 }\n",
    "print(dict1)\n",
    "\n",
    "for key, value in dict1.items():\n",
    "    print(key, value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "32f4103f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1,\n",
       " 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",
       " 31,\n",
       " 32,\n",
       " 33,\n",
       " 34,\n",
       " 35,\n",
       " 36,\n",
       " 37,\n",
       " 38,\n",
       " 39,\n",
       " 40,\n",
       " 41,\n",
       " 42,\n",
       " 43,\n",
       " 44,\n",
       " 45,\n",
       " 46,\n",
       " 47,\n",
       " 48,\n",
       " 49,\n",
       " 50,\n",
       " 51,\n",
       " 52,\n",
       " 53,\n",
       " 54,\n",
       " 55,\n",
       " 56,\n",
       " 57,\n",
       " 58,\n",
       " 59,\n",
       " 60,\n",
       " 61,\n",
       " 62,\n",
       " 63,\n",
       " 64,\n",
       " 65,\n",
       " 66,\n",
       " 67,\n",
       " 68,\n",
       " 69,\n",
       " 70,\n",
       " 71,\n",
       " 72,\n",
       " 73,\n",
       " 74,\n",
       " 75,\n",
       " 76,\n",
       " 77,\n",
       " 78,\n",
       " 79,\n",
       " 80,\n",
       " 81,\n",
       " 82,\n",
       " 83,\n",
       " 84,\n",
       " 85,\n",
       " 86,\n",
       " 87,\n",
       " 88,\n",
       " 89,\n",
       " 90,\n",
       " 91,\n",
       " 92,\n",
       " 93,\n",
       " 94,\n",
       " 95,\n",
       " 96,\n",
       " 97,\n",
       " 98,\n",
       " 99,\n",
       " 100]"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(range(1, 101))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7fda43c8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n"
     ]
    }
   ],
   "source": [
    "# 1~10까지 리스트로 생성\n",
    "numbers = []\n",
    "for i in range(1, 11):\n",
    "    numbers.append(i)\n",
    "\n",
    "print(numbers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "17b64a5a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['b', 'c', 'd']\n"
     ]
    }
   ],
   "source": [
    "# 리스트 컴프리헨션\n",
    "\n",
    "list2 = [\"A\", \"b\", \"c\", \"E\", \"Q\", \"d\"]\n",
    "\n",
    "# 소문자만 골라서 새로운 리스트 생성\n",
    "# lowers = []\n",
    "# for s in list2:\n",
    "#     if s.islower():\n",
    "#         lowers.append(s)\n",
    "\n",
    "# print(lowers)\n",
    "\n",
    "lowers = [s for s in list2 if s.islower()]\n",
    "print(lowers)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9fb9fb21",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 6, 9, 12, 15]\n"
     ]
    }
   ],
   "source": [
    "nums = [1, 2, 3, 4, 5]\n",
    "\n",
    "# nums의 각 요소에 * 3 한 결과 results 새로운 리스트 생성\n",
    "results = [n * 3 for n in nums]\n",
    "print(results)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ec857421",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[6, 12]\n"
     ]
    }
   ],
   "source": [
    "# nums의 각 요소에 짝수에 * 3 한 결과 results 새로운 리스트 생성\n",
    "results = [n * 3 for n in nums if n % 2 == 0]\n",
    "print(results)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "2794cdae",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "65"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 리스트\n",
    "# 반복문, 조건문\n",
    "\n",
    "ord(\"A\") # 65\n",
    "chr(65) # \"A\"\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "0b0e8214",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A 자동차가 주차되었습니다. 주차장 상태 : ['A']\n",
      "주차장이 비어 있습니다.\n",
      "A 자동차가 주차되었습니다. 주차장 상태 : ['A']\n",
      "주차장이 비어 있습니다.\n",
      "A 자동차가 주차되었습니다. 주차장 상태 : ['A']\n",
      "B 자동차가 주차되었습니다. 주차장 상태 : ['A', 'B']\n",
      "C 자동차가 주차되었습니다. 주차장 상태 : ['A', 'B', 'C']\n",
      "C 자동차가 출차되었습니다. 주차장 상태 : ['A', 'B']\n",
      "B 자동차가 출차되었습니다. 주차장 상태 : ['A']\n",
      "주차장이 비어 있습니다.\n",
      "프로그램을 종료합니다.\n"
     ]
    }
   ],
   "source": [
    "# 주차장 프로그램?\n",
    "# 5대의 주차 공간, a, b,c, d, e\n",
    "\n",
    "# 메뉴 제공\n",
    "# [1] 주차 [2] 출차 [3] 종료\n",
    "\n",
    "# 1번 선택 => a 자동차 들어감. 주차장 상태 => ['a']\n",
    "# 1번 선택 => b 자동차 들어감. 주차장 상태 => ['a', 'b']\n",
    "# 2번 선택 => b 자동차 나감. 주차장 상태 => ['a']\n",
    "\n",
    "# 5대의 주차 공간이 모두 찼을 때 1번 선택 => \"주차 공간이 없습니다.\"\n",
    "\n",
    "parking_lot = []\n",
    "\n",
    "while True:\n",
    "    menu = input(\"[1] 주차 | [2] 출차 | [3] 종료 : 숫자만 입력하시오 = \")\n",
    "    \n",
    "    if menu == \"1\":\n",
    "        if len(parking_lot) < 5:\n",
    "            car = len(parking_lot) + 65 # \"A\"\n",
    "            parking_lot.append(car)\n",
    "            print(f\"{chr(car)} 자동차가 주차되었습니다. 주차장 상태 : {[chr(c) for c in parking_lot]}\")\n",
    "        else:\n",
    "            print(\"주차 공간이 없습니다.\")\n",
    "            \n",
    "    elif menu == \"2\":\n",
    "        if parking_lot:\n",
    "            car = parking_lot.pop()\n",
    "            \n",
    "            if not parking_lot:\n",
    "                print(\"주차장이 비어 있습니다.\")\n",
    "            else:\n",
    "                print(f\"{chr(car)} 자동차가 출차되었습니다. 주차장 상태 : {[chr(c) for c in parking_lot]}\")\n",
    "        else:\n",
    "            print(\"주차장이 비어 있습니다.\")\n",
    "            \n",
    "    elif menu == \"3\":\n",
    "        print(\"프로그램을 종료합니다.\")\n",
    "        break\n",
    "        \n",
    "    else:\n",
    "        print(\"잘못된 선택입니다. 다시 선택해주세요.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f59c8442",
   "metadata": {},
   "source": [
    "### 함수\n",
    " \n",
    "```python\n",
    "def 함수명() :\n",
    "    함수에서 해야할 일들\n",
    "```\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "047354a6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "30\n"
     ]
    }
   ],
   "source": [
    "#range()\n",
    "#int()\n",
    "#input()\n",
    "#len()\n",
    "#str()\n",
    "#list()\n",
    "#tuple()\n",
    "#dict()\n",
    "#set()\n",
    "#type()\n",
    "#print()\n",
    "\n",
    "# 함수 정의\n",
    "def add(a, b):\n",
    "    return a + b\n",
    "\n",
    "results = add(10, 20)\n",
    "print(results)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "9941c444",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12\n"
     ]
    }
   ],
   "source": [
    "print(add(5, 7))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "51e1a73e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "def add(a, b = 5):\n",
    "    return a + b\n",
    "\n",
    "print(add(5, 7))\n",
    "print(add(5))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "fc28339e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15\n",
      "50\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "def add_many(*args):\n",
    "    total = 0\n",
    "    for num in args:\n",
    "        total += num\n",
    "    return total\n",
    "\n",
    "print(add_many(1, 2, 3, 4, 5))\n",
    "print(add_many(1, 19, 30))\n",
    "print(add_many())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "id": "9071a280",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15\n",
      "120\n"
     ]
    }
   ],
   "source": [
    "def add_many(choice, *args):\n",
    "\n",
    "    if choice == \"mul\":\n",
    "        result = 1\n",
    "        for num in args:\n",
    "            result *= num\n",
    "    elif choice == \"add\":\n",
    "        result = 0\n",
    "        for num in args:\n",
    "            result += num\n",
    "    return result\n",
    "\n",
    "print(add_many(\"add\", 1, 2, 3, 4, 5))\n",
    "print(add_many(\"mul\", 1, 2, 3, 4, 5))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "id": "30c1ea8f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a : 1\n",
      "b : 2\n",
      "c : 3\n",
      "d : 4\n",
      "e : 5\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "# ** kwargs : 키워드 인수, 함수에 전달되는 인수 중에서 키워드 인수는 함수 정의에서 매개변수 이름과 함께 값을 전달하는 방식입니다. 키워드 인수를 사용하면 함수 호출 시 매개변수의 순서에 상관없이 값을 전달할 수 있습니다. 예를 들어, def func(a, b): ...와 같이 함수가 정의되어 있을 때, func(b=2, a=1)와 같이 키워드 인수를 사용하여 값을 전달할 수 있습니다. 키워드 인수는 함수 호출 시 가독성을 높이고, 매개변수의 순서를 신경쓰지 않아도 되는 장점이 있습니다.\n",
    "# *args : 가변 인수, 함수에 전달되는 인수 중에서 가변 인수는 함수 정의에서 매개변수 이름 앞에 *를 붙여서 정의하는 방식입니다. 가변 인수를 사용하면 함수 호출 시 전달되는 인수의 개수가 가변적일 수 있습니다. 예를 들어, def func(*args): ...와 같이 함수가 정의되어 있을 때, func(1, 2, 3)와 같이 여러 개의 인수를 전달할 수 있습니다. 가변 인수는 함수 호출 시 다양한 개수의 인수를 처리할 때 유용하게 사용됩니다.\n",
    "# 변수명 : 1:1 대응\n",
    "\n",
    "def add_many(**kwargs):\n",
    "    for k, v in kwargs.items():\n",
    "        print(f\"{k} : {v}\")\n",
    "\n",
    "print(add_many(a=1, b=2, c=3, d=4, e=5))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "id": "4662bc09",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 5 () {}\n",
      "1 2 () {}\n",
      "1 2 (3, 4, 5) {}\n",
      "1 2 () {'a': 6, 'b': 7}\n",
      "1 2 (3, 4, 5) {'a': 6, 'b': 7}\n"
     ]
    }
   ],
   "source": [
    "def example_mul(arg1, arg2=5, *args, **kwargs):\n",
    "    print(arg1, arg2, args, kwargs)\n",
    "    \n",
    "# example_mul()\n",
    "example_mul(10)\n",
    "example_mul(1, 2)\n",
    "example_mul(1, 2, 3, 4, 5)\n",
    "example_mul(1, 2, a=6, b=7)\n",
    "example_mul(1, 2, 3, 4, 5, a=6, b=7)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "id": "db75df55",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(7, 12)\n"
     ]
    }
   ],
   "source": [
    "def sum_add(a, b):\n",
    "    return a + b, a * b\n",
    "\n",
    "print(sum_add(3, 4))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a9ea151c",
   "metadata": {},
   "source": [
    "### lamda 함수\n",
    "- 단일문으로 표현되는 익명 함수\n",
    "- 1회용 함수로 주로 사용"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ddf88de2",
   "metadata": {},
   "outputs": [],
   "source": [
    "### lamda 함수\n",
    "- 단일문으로 표현되는 익명 함수\n",
    "- 1회용 함수로 주로 사용"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "id": "de8dbeda",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "25\n",
      "25\n"
     ]
    }
   ],
   "source": [
    "def square(x):\n",
    "    return x ** 2\n",
    "\n",
    "print(square(5))\n",
    "\n",
    "# lambda 함수로 표현\n",
    "square_lambda = lambda x: x ** 2\n",
    "print(square_lambda(5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "id": "9f63beb3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n"
     ]
    }
   ],
   "source": [
    "#def add(a, b=5):\n",
    "#    return a + b\n",
    "\n",
    "lambda_add = lambda a, b: a + b\n",
    "print(lambda_add(3, 4))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "id": "1a999f77",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['bob', 'alice', 'teddy', 'charles']\n"
     ]
    }
   ],
   "source": [
    "string = [\"bob\", \"charles\", \"alice\", \"teddy\"]\n",
    "\n",
    "#sort() : 내림 오름\n",
    "string.sort()\n",
    "\n",
    "#sort(key = 함수) : 문자길이 정렬\n",
    "\n",
    "# def str_len(s):\n",
    "#     return len(s)\n",
    "\n",
    "# string.sort(key=str_len)\n",
    "# string\n",
    "string.sort(key=lambda s: len(s))\n",
    "print(string)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "id": "19157dae",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 4, 6, 8, 10]\n",
      "[2, 4, 6, 8, 10]\n"
     ]
    }
   ],
   "source": [
    "# filter, map\n",
    "\n",
    "# 넘겨받은 리스트에서 짝수만을 추출후 새로운 리스트로 리턴\n",
    "\n",
    "def even(arr):\n",
    "    even_list = []\n",
    "    for n in arr:\n",
    "        if n % 2 == 0:\n",
    "            even_list.append(n)\n",
    "    return even_list\n",
    "\n",
    "list1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
    "even_list = even(list1)\n",
    "print(even_list)\n",
    "\n",
    "def is_even(n):\n",
    "    return n % 2 == 0\n",
    "\n",
    "numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
    "even_numbers = filter(is_even, numbers)\n",
    "print(list(even_numbers))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "id": "4fdbc48c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 4, 6, 8, 10]"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(filter(lambda n: n % 2 == 0, numbers))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "id": "b4da5d8e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[False, True, False, True, False, True, False, True, False, True]"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(map(lambda n: n %2==0, numbers))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "881aeb4d",
   "metadata": {},
   "source": [
    "# 파일 입출력\n",
    "\n",
    "``` open(파일이름, mode) ```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "id": "eb3148ee",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 파일 읽기\n",
    "f1 = open(\"test.txt\", \"r\") # 파일을 읽기 모드로 엽니다. open() 함수는 파일을 열 때 사용되며, 첫 번째 매개변수로 파일 경로를, 두 번째 매개변수로 파일 모드를 지정합니다. \"r\" 모드는 읽기 모드로 파일을 열며, 파일이 존재하지 않으면 FileNotFoundError 예외를 발생시킵니다. open() 함수는 파일 객체를 반환하며, 이후에 파일 작업을 수행할 수 있습니다.     \n",
    "# 파일 쓰기\n",
    "f2 = open(\"test.txt\", \"w\") # 파일을 쓰기 모드로 엽니다\n",
    "# 파일에 내용 추가  \n",
    "f3 = open(\"test.txt\", \"a\") # 파일을 추가 모드로 엽니다. open() 함수는 파일을 열 때 사용되며, 첫 번째 매개변수로 파일 경로를, 두 번째 매개변수로 파일 모드를 지정합니다. \"a\" 모드는 추가 모드로 파일을 열며, 파일이 존재하지 않으면 새로 생성합니다. open() 함수는 파일 객체를 반환하며, 이후에 파일 작업을 수행할 수 있습니다. 추가 모드는 기존 파일의 내용을 유지하면서 새로운 내용을 추가할 때 유용하게 사용됩니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "id": "f58cb422",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "test\n"
     ]
    }
   ],
   "source": [
    "f1 = open(\"test.txt\", \"r\", encoding=\"utf-8\") # 파일을 읽기 모드로 열면서 인코딩을 utf-8로 지정합니다. open() 함수는 파일을 열 때 사용되며, 첫 번째 매개변수로 파일 경로를, 두 번째 매개변수로 파일 모드를 지정합니다. \"r\" 모드는 읽기 모드로 파일을 열며, encoding=\"utf-8\"은 파일의 인코딩을 utf-8로 지정하는 옵션입니다. open() 함수는 파일 객체를 반환하며, 이후에 파일 작업을 수행할 수 있습니다. 인코딩을 지정하면 파일의 내용을 올바르게 읽어들일 수 있습니다.\n",
    "print(f1.read()) # 파일의 전체 내용을 읽어서 문자열로 반환하는 함수입니다. read() 함수는 파일 객체에서 전체 내용을 읽어들이며, 반환값은 문자열입니다. 예를 들어, f1.read()는 f1 파일 객체에서 전체 내용을 읽어서 문자열로 반환합니다. read() 함수는 파일의 내용을 한 번에 읽어들일 때 유용하게 사용됩니다.  \n",
    "f1.close() # 파일을 닫습니다. close() 함수는 파일 작업이 끝난 후에 파일을 닫을 때 사용됩니다. 파일을 열 때 open() 함수를 사용하여 파일 객체를 생성한 후, 작업이 완료되면 close() 함수를 호출하여 파일을 닫아야 합니다. close() 함수를 호출하지 않으면 파일이 계속 열려 있을 수 있으며, 이는 시스템 자원을 낭비할 수 있습니다. 따라서 파일 작업이 끝난 후에는 반드시 close() 함수를 호출하여 파일을 닫는 것이 좋습니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "id": "9958ad37",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "test\n"
     ]
    }
   ],
   "source": [
    "with open(\"test.txt\", \"r\", encoding=\"utf-8\") as f1:\n",
    "    print(f1.read()) # with 문을 사용하여 파일을 열면, 블록이 끝날 때 자동으로 파일이 닫힙니다. 따라서 with open(\"test.txt\", \"r\", encoding=\"utf-8\") as f1:와 같이 파일을 열고, 블록 내에서 f1.read()를 호출하여 파일의 내용을 읽어들인 후, 블록이 끝나면 자동으로 f1 파일 객체가 닫히게 됩니다. with 문은 파일 작업을 안전하게 처리할 수 있도록 도와주며, 파일을 열고 닫는 것을 자동으로 관리해줍니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "id": "55b73588",
   "metadata": {},
   "outputs": [],
   "source": [
    "with open(\"test2.txt\", \"w\", encoding=\"utf-8\") as f1:\n",
    "    for i in range(3):\n",
    "        f1.write(f\"Line {i+1}\\n\") # 파일 객체 f1에 문자열을 쓰는 함수입니다. write() 함수는 파일 객체에 문자열을 쓰며, 반환값은 쓰여진 문자열의 길이입니다. 예를 들어, f1.write(f\"Line {i+1}\\n\")는 f1 파일 객체에 \"Line 1\\n\", \"Line 2\\n\", \"Line 3\\n\"과 같은 문자열을 순차적으로 쓰게 됩니다. write() 함수는 파일에 데이터를 기록할 때 유용하게 사용됩니다.  \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "id": "3b92d329",
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "hanguls = list(\"가나다라마바사아자차카타파하\")\n",
    "with open(\"info.txt\", \"w\", encoding=\"utf-8\") as f1:\n",
    "    for i in range(500):\n",
    "        name = random.choice(hanguls) + random.choice(hanguls)\n",
    "        weight = random.randint(40, 100)\n",
    "        height = random.randint(140, 200)\n",
    "        f1.write(f\"{name} {weight} {height}\\n\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "id": "8753e450",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "파다 98 170\n",
      "\n",
      " 이름 : 파다, 몸무게 : 98kg, 키 : 170cm, bmi 지수 : 33.91, 결과 : 과체중\n",
      "\n",
      "차카 63 194\n",
      "\n",
      " 이름 : 차카, 몸무게 : 63kg, 키 : 194cm, bmi 지수 : 16.74, 결과 : 저체중\n",
      "\n",
      "바카 42 152\n",
      "\n",
      " 이름 : 바카, 몸무게 : 42kg, 키 : 152cm, bmi 지수 : 18.18, 결과 : 저체중\n",
      "\n",
      "마파 62 157\n",
      "\n",
      " 이름 : 마파, 몸무게 : 62kg, 키 : 157cm, bmi 지수 : 25.15, 결과 : 과체중\n",
      "\n",
      "라마 77 156\n",
      "\n",
      " 이름 : 라마, 몸무게 : 77kg, 키 : 156cm, bmi 지수 : 31.64, 결과 : 과체중\n",
      "\n",
      "카다 40 143\n",
      "\n",
      " 이름 : 카다, 몸무게 : 40kg, 키 : 143cm, bmi 지수 : 19.56, 결과 : 정상\n",
      "\n",
      "가하 63 150\n",
      "\n",
      " 이름 : 가하, 몸무게 : 63kg, 키 : 150cm, bmi 지수 : 28.00, 결과 : 과체중\n",
      "\n",
      "라가 78 153\n",
      "\n",
      " 이름 : 라가, 몸무게 : 78kg, 키 : 153cm, bmi 지수 : 33.32, 결과 : 과체중\n",
      "\n",
      "라자 88 189\n",
      "\n",
      " 이름 : 라자, 몸무게 : 88kg, 키 : 189cm, bmi 지수 : 24.64, 결과 : 정상\n",
      "\n",
      "파다 47 186\n",
      "\n",
      " 이름 : 파다, 몸무게 : 47kg, 키 : 186cm, bmi 지수 : 13.59, 결과 : 저체중\n",
      "\n",
      "파가 50 168\n",
      "\n",
      " 이름 : 파가, 몸무게 : 50kg, 키 : 168cm, bmi 지수 : 17.72, 결과 : 저체중\n",
      "\n",
      "바타 59 194\n",
      "\n",
      " 이름 : 바타, 몸무게 : 59kg, 키 : 194cm, bmi 지수 : 15.68, 결과 : 저체중\n",
      "\n",
      "파사 63 196\n",
      "\n",
      " 이름 : 파사, 몸무게 : 63kg, 키 : 196cm, bmi 지수 : 16.40, 결과 : 저체중\n",
      "\n",
      "하차 87 195\n",
      "\n",
      " 이름 : 하차, 몸무게 : 87kg, 키 : 195cm, bmi 지수 : 22.88, 결과 : 정상\n",
      "\n",
      "마파 65 152\n",
      "\n",
      " 이름 : 마파, 몸무게 : 65kg, 키 : 152cm, bmi 지수 : 28.13, 결과 : 과체중\n",
      "\n",
      "하파 62 145\n",
      "\n",
      " 이름 : 하파, 몸무게 : 62kg, 키 : 145cm, bmi 지수 : 29.49, 결과 : 과체중\n",
      "\n",
      "차바 69 159\n",
      "\n",
      " 이름 : 차바, 몸무게 : 69kg, 키 : 159cm, bmi 지수 : 27.29, 결과 : 과체중\n",
      "\n",
      "카차 70 196\n",
      "\n",
      " 이름 : 카차, 몸무게 : 70kg, 키 : 196cm, bmi 지수 : 18.22, 결과 : 저체중\n",
      "\n",
      "바라 48 147\n",
      "\n",
      " 이름 : 바라, 몸무게 : 48kg, 키 : 147cm, bmi 지수 : 22.21, 결과 : 정상\n",
      "\n",
      "자나 43 146\n",
      "\n",
      " 이름 : 자나, 몸무게 : 43kg, 키 : 146cm, bmi 지수 : 20.17, 결과 : 정상\n",
      "\n",
      "파마 88 149\n",
      "\n",
      " 이름 : 파마, 몸무게 : 88kg, 키 : 149cm, bmi 지수 : 39.64, 결과 : 과체중\n",
      "\n",
      "나나 67 155\n",
      "\n",
      " 이름 : 나나, 몸무게 : 67kg, 키 : 155cm, bmi 지수 : 27.89, 결과 : 과체중\n",
      "\n",
      "파가 49 152\n",
      "\n",
      " 이름 : 파가, 몸무게 : 49kg, 키 : 152cm, bmi 지수 : 21.21, 결과 : 정상\n",
      "\n",
      "자차 96 140\n",
      "\n",
      " 이름 : 자차, 몸무게 : 96kg, 키 : 140cm, bmi 지수 : 48.98, 결과 : 과체중\n",
      "\n",
      "사마 88 184\n",
      "\n",
      " 이름 : 사마, 몸무게 : 88kg, 키 : 184cm, bmi 지수 : 25.99, 결과 : 과체중\n",
      "\n",
      "사바 90 174\n",
      "\n",
      " 이름 : 사바, 몸무게 : 90kg, 키 : 174cm, bmi 지수 : 29.73, 결과 : 과체중\n",
      "\n",
      "나라 58 167\n",
      "\n",
      " 이름 : 나라, 몸무게 : 58kg, 키 : 167cm, bmi 지수 : 20.80, 결과 : 정상\n",
      "\n",
      "파나 66 152\n",
      "\n",
      " 이름 : 파나, 몸무게 : 66kg, 키 : 152cm, bmi 지수 : 28.57, 결과 : 과체중\n",
      "\n",
      "타나 86 170\n",
      "\n",
      " 이름 : 타나, 몸무게 : 86kg, 키 : 170cm, bmi 지수 : 29.76, 결과 : 과체중\n",
      "\n",
      "아나 93 195\n",
      "\n",
      " 이름 : 아나, 몸무게 : 93kg, 키 : 195cm, bmi 지수 : 24.46, 결과 : 정상\n",
      "\n",
      "사하 61 151\n",
      "\n",
      " 이름 : 사하, 몸무게 : 61kg, 키 : 151cm, bmi 지수 : 26.75, 결과 : 과체중\n",
      "\n",
      "타하 85 142\n",
      "\n",
      " 이름 : 타하, 몸무게 : 85kg, 키 : 142cm, bmi 지수 : 42.15, 결과 : 과체중\n",
      "\n",
      "카차 73 140\n",
      "\n",
      " 이름 : 카차, 몸무게 : 73kg, 키 : 140cm, bmi 지수 : 37.24, 결과 : 과체중\n",
      "\n",
      "카마 90 157\n",
      "\n",
      " 이름 : 카마, 몸무게 : 90kg, 키 : 157cm, bmi 지수 : 36.51, 결과 : 과체중\n",
      "\n",
      "가가 41 180\n",
      "\n",
      " 이름 : 가가, 몸무게 : 41kg, 키 : 180cm, bmi 지수 : 12.65, 결과 : 저체중\n",
      "\n",
      "나나 56 198\n",
      "\n",
      " 이름 : 나나, 몸무게 : 56kg, 키 : 198cm, bmi 지수 : 14.28, 결과 : 저체중\n",
      "\n",
      "다파 40 161\n",
      "\n",
      " 이름 : 다파, 몸무게 : 40kg, 키 : 161cm, bmi 지수 : 15.43, 결과 : 저체중\n",
      "\n",
      "나카 62 170\n",
      "\n",
      " 이름 : 나카, 몸무게 : 62kg, 키 : 170cm, bmi 지수 : 21.45, 결과 : 정상\n",
      "\n",
      "차다 88 187\n",
      "\n",
      " 이름 : 차다, 몸무게 : 88kg, 키 : 187cm, bmi 지수 : 25.17, 결과 : 과체중\n",
      "\n",
      "가자 45 150\n",
      "\n",
      " 이름 : 가자, 몸무게 : 45kg, 키 : 150cm, bmi 지수 : 20.00, 결과 : 정상\n",
      "\n",
      "사다 80 195\n",
      "\n",
      " 이름 : 사다, 몸무게 : 80kg, 키 : 195cm, bmi 지수 : 21.04, 결과 : 정상\n",
      "\n",
      "카바 84 192\n",
      "\n",
      " 이름 : 카바, 몸무게 : 84kg, 키 : 192cm, bmi 지수 : 22.79, 결과 : 정상\n",
      "\n",
      "하자 98 164\n",
      "\n",
      " 이름 : 하자, 몸무게 : 98kg, 키 : 164cm, bmi 지수 : 36.44, 결과 : 과체중\n",
      "\n",
      "카자 92 177\n",
      "\n",
      " 이름 : 카자, 몸무게 : 92kg, 키 : 177cm, bmi 지수 : 29.37, 결과 : 과체중\n",
      "\n",
      "다다 41 150\n",
      "\n",
      " 이름 : 다다, 몸무게 : 41kg, 키 : 150cm, bmi 지수 : 18.22, 결과 : 저체중\n",
      "\n",
      "아타 86 170\n",
      "\n",
      " 이름 : 아타, 몸무게 : 86kg, 키 : 170cm, bmi 지수 : 29.76, 결과 : 과체중\n",
      "\n",
      "마카 50 182\n",
      "\n",
      " 이름 : 마카, 몸무게 : 50kg, 키 : 182cm, bmi 지수 : 15.09, 결과 : 저체중\n",
      "\n",
      "마자 72 175\n",
      "\n",
      " 이름 : 마자, 몸무게 : 72kg, 키 : 175cm, bmi 지수 : 23.51, 결과 : 정상\n",
      "\n",
      "사다 40 158\n",
      "\n",
      " 이름 : 사다, 몸무게 : 40kg, 키 : 158cm, bmi 지수 : 16.02, 결과 : 저체중\n",
      "\n",
      "사아 93 174\n",
      "\n",
      " 이름 : 사아, 몸무게 : 93kg, 키 : 174cm, bmi 지수 : 30.72, 결과 : 과체중\n",
      "\n",
      "가라 58 153\n",
      "\n",
      " 이름 : 가라, 몸무게 : 58kg, 키 : 153cm, bmi 지수 : 24.78, 결과 : 정상\n",
      "\n",
      "자아 77 196\n",
      "\n",
      " 이름 : 자아, 몸무게 : 77kg, 키 : 196cm, bmi 지수 : 20.04, 결과 : 정상\n",
      "\n",
      "아바 42 162\n",
      "\n",
      " 이름 : 아바, 몸무게 : 42kg, 키 : 162cm, bmi 지수 : 16.00, 결과 : 저체중\n",
      "\n",
      "마하 56 175\n",
      "\n",
      " 이름 : 마하, 몸무게 : 56kg, 키 : 175cm, bmi 지수 : 18.29, 결과 : 저체중\n",
      "\n",
      "파파 93 187\n",
      "\n",
      " 이름 : 파파, 몸무게 : 93kg, 키 : 187cm, bmi 지수 : 26.59, 결과 : 과체중\n",
      "\n",
      "파마 91 172\n",
      "\n",
      " 이름 : 파마, 몸무게 : 91kg, 키 : 172cm, bmi 지수 : 30.76, 결과 : 과체중\n",
      "\n",
      "카다 80 146\n",
      "\n",
      " 이름 : 카다, 몸무게 : 80kg, 키 : 146cm, bmi 지수 : 37.53, 결과 : 과체중\n",
      "\n",
      "가다 95 166\n",
      "\n",
      " 이름 : 가다, 몸무게 : 95kg, 키 : 166cm, bmi 지수 : 34.48, 결과 : 과체중\n",
      "\n",
      "카카 42 150\n",
      "\n",
      " 이름 : 카카, 몸무게 : 42kg, 키 : 150cm, bmi 지수 : 18.67, 결과 : 정상\n",
      "\n",
      "라차 50 191\n",
      "\n",
      " 이름 : 라차, 몸무게 : 50kg, 키 : 191cm, bmi 지수 : 13.71, 결과 : 저체중\n",
      "\n",
      "아바 95 143\n",
      "\n",
      " 이름 : 아바, 몸무게 : 95kg, 키 : 143cm, bmi 지수 : 46.46, 결과 : 과체중\n",
      "\n",
      "바마 91 175\n",
      "\n",
      " 이름 : 바마, 몸무게 : 91kg, 키 : 175cm, bmi 지수 : 29.71, 결과 : 과체중\n",
      "\n",
      "파라 85 164\n",
      "\n",
      " 이름 : 파라, 몸무게 : 85kg, 키 : 164cm, bmi 지수 : 31.60, 결과 : 과체중\n",
      "\n",
      "마라 85 168\n",
      "\n",
      " 이름 : 마라, 몸무게 : 85kg, 키 : 168cm, bmi 지수 : 30.12, 결과 : 과체중\n",
      "\n",
      "자하 89 192\n",
      "\n",
      " 이름 : 자하, 몸무게 : 89kg, 키 : 192cm, bmi 지수 : 24.14, 결과 : 정상\n",
      "\n",
      "사아 99 197\n",
      "\n",
      " 이름 : 사아, 몸무게 : 99kg, 키 : 197cm, bmi 지수 : 25.51, 결과 : 과체중\n",
      "\n",
      "사차 61 172\n",
      "\n",
      " 이름 : 사차, 몸무게 : 61kg, 키 : 172cm, bmi 지수 : 20.62, 결과 : 정상\n",
      "\n",
      "차차 76 162\n",
      "\n",
      " 이름 : 차차, 몸무게 : 76kg, 키 : 162cm, bmi 지수 : 28.96, 결과 : 과체중\n",
      "\n",
      "다차 83 191\n",
      "\n",
      " 이름 : 다차, 몸무게 : 83kg, 키 : 191cm, bmi 지수 : 22.75, 결과 : 정상\n",
      "\n",
      "나타 63 150\n",
      "\n",
      " 이름 : 나타, 몸무게 : 63kg, 키 : 150cm, bmi 지수 : 28.00, 결과 : 과체중\n",
      "\n",
      "하사 91 150\n",
      "\n",
      " 이름 : 하사, 몸무게 : 91kg, 키 : 150cm, bmi 지수 : 40.44, 결과 : 과체중\n",
      "\n",
      "카사 59 162\n",
      "\n",
      " 이름 : 카사, 몸무게 : 59kg, 키 : 162cm, bmi 지수 : 22.48, 결과 : 정상\n",
      "\n",
      "카차 87 197\n",
      "\n",
      " 이름 : 카차, 몸무게 : 87kg, 키 : 197cm, bmi 지수 : 22.42, 결과 : 정상\n",
      "\n",
      "카바 61 181\n",
      "\n",
      " 이름 : 카바, 몸무게 : 61kg, 키 : 181cm, bmi 지수 : 18.62, 결과 : 정상\n",
      "\n",
      "바파 58 168\n",
      "\n",
      " 이름 : 바파, 몸무게 : 58kg, 키 : 168cm, bmi 지수 : 20.55, 결과 : 정상\n",
      "\n",
      "카타 93 200\n",
      "\n",
      " 이름 : 카타, 몸무게 : 93kg, 키 : 200cm, bmi 지수 : 23.25, 결과 : 정상\n",
      "\n",
      "나나 51 194\n",
      "\n",
      " 이름 : 나나, 몸무게 : 51kg, 키 : 194cm, bmi 지수 : 13.55, 결과 : 저체중\n",
      "\n",
      "다가 92 169\n",
      "\n",
      " 이름 : 다가, 몸무게 : 92kg, 키 : 169cm, bmi 지수 : 32.21, 결과 : 과체중\n",
      "\n",
      "가나 82 145\n",
      "\n",
      " 이름 : 가나, 몸무게 : 82kg, 키 : 145cm, bmi 지수 : 39.00, 결과 : 과체중\n",
      "\n",
      "카파 77 177\n",
      "\n",
      " 이름 : 카파, 몸무게 : 77kg, 키 : 177cm, bmi 지수 : 24.58, 결과 : 정상\n",
      "\n",
      "타하 54 157\n",
      "\n",
      " 이름 : 타하, 몸무게 : 54kg, 키 : 157cm, bmi 지수 : 21.91, 결과 : 정상\n",
      "\n",
      "차바 44 165\n",
      "\n",
      " 이름 : 차바, 몸무게 : 44kg, 키 : 165cm, bmi 지수 : 16.16, 결과 : 저체중\n",
      "\n",
      "사파 58 142\n",
      "\n",
      " 이름 : 사파, 몸무게 : 58kg, 키 : 142cm, bmi 지수 : 28.76, 결과 : 과체중\n",
      "\n",
      "나카 83 157\n",
      "\n",
      " 이름 : 나카, 몸무게 : 83kg, 키 : 157cm, bmi 지수 : 33.67, 결과 : 과체중\n",
      "\n",
      "다가 59 151\n",
      "\n",
      " 이름 : 다가, 몸무게 : 59kg, 키 : 151cm, bmi 지수 : 25.88, 결과 : 과체중\n",
      "\n",
      "마카 45 144\n",
      "\n",
      " 이름 : 마카, 몸무게 : 45kg, 키 : 144cm, bmi 지수 : 21.70, 결과 : 정상\n",
      "\n",
      "마파 72 169\n",
      "\n",
      " 이름 : 마파, 몸무게 : 72kg, 키 : 169cm, bmi 지수 : 25.21, 결과 : 과체중\n",
      "\n",
      "라아 54 188\n",
      "\n",
      " 이름 : 라아, 몸무게 : 54kg, 키 : 188cm, bmi 지수 : 15.28, 결과 : 저체중\n",
      "\n",
      "타자 89 177\n",
      "\n",
      " 이름 : 타자, 몸무게 : 89kg, 키 : 177cm, bmi 지수 : 28.41, 결과 : 과체중\n",
      "\n",
      "나나 48 198\n",
      "\n",
      " 이름 : 나나, 몸무게 : 48kg, 키 : 198cm, bmi 지수 : 12.24, 결과 : 저체중\n",
      "\n",
      "파사 75 168\n",
      "\n",
      " 이름 : 파사, 몸무게 : 75kg, 키 : 168cm, bmi 지수 : 26.57, 결과 : 과체중\n",
      "\n",
      "바다 95 157\n",
      "\n",
      " 이름 : 바다, 몸무게 : 95kg, 키 : 157cm, bmi 지수 : 38.54, 결과 : 과체중\n",
      "\n",
      "아아 58 189\n",
      "\n",
      " 이름 : 아아, 몸무게 : 58kg, 키 : 189cm, bmi 지수 : 16.24, 결과 : 저체중\n",
      "\n",
      "아가 72 174\n",
      "\n",
      " 이름 : 아가, 몸무게 : 72kg, 키 : 174cm, bmi 지수 : 23.78, 결과 : 정상\n",
      "\n",
      "카아 78 156\n",
      "\n",
      " 이름 : 카아, 몸무게 : 78kg, 키 : 156cm, bmi 지수 : 32.05, 결과 : 과체중\n",
      "\n",
      "타바 50 168\n",
      "\n",
      " 이름 : 타바, 몸무게 : 50kg, 키 : 168cm, bmi 지수 : 17.72, 결과 : 저체중\n",
      "\n",
      "다사 87 163\n",
      "\n",
      " 이름 : 다사, 몸무게 : 87kg, 키 : 163cm, bmi 지수 : 32.74, 결과 : 과체중\n",
      "\n",
      "라다 83 145\n",
      "\n",
      " 이름 : 라다, 몸무게 : 83kg, 키 : 145cm, bmi 지수 : 39.48, 결과 : 과체중\n",
      "\n",
      "다라 97 140\n",
      "\n",
      " 이름 : 다라, 몸무게 : 97kg, 키 : 140cm, bmi 지수 : 49.49, 결과 : 과체중\n",
      "\n",
      "마가 88 143\n",
      "\n",
      " 이름 : 마가, 몸무게 : 88kg, 키 : 143cm, bmi 지수 : 43.03, 결과 : 과체중\n",
      "\n",
      "라파 88 183\n",
      "\n",
      " 이름 : 라파, 몸무게 : 88kg, 키 : 183cm, bmi 지수 : 26.28, 결과 : 과체중\n",
      "\n",
      "하카 51 199\n",
      "\n",
      " 이름 : 하카, 몸무게 : 51kg, 키 : 199cm, bmi 지수 : 12.88, 결과 : 저체중\n",
      "\n",
      "자다 41 172\n",
      "\n",
      " 이름 : 자다, 몸무게 : 41kg, 키 : 172cm, bmi 지수 : 13.86, 결과 : 저체중\n",
      "\n",
      "자하 70 175\n",
      "\n",
      " 이름 : 자하, 몸무게 : 70kg, 키 : 175cm, bmi 지수 : 22.86, 결과 : 정상\n",
      "\n",
      "마다 66 184\n",
      "\n",
      " 이름 : 마다, 몸무게 : 66kg, 키 : 184cm, bmi 지수 : 19.49, 결과 : 정상\n",
      "\n",
      "바자 93 173\n",
      "\n",
      " 이름 : 바자, 몸무게 : 93kg, 키 : 173cm, bmi 지수 : 31.07, 결과 : 과체중\n",
      "\n",
      "가차 100 175\n",
      "\n",
      " 이름 : 가차, 몸무게 : 100kg, 키 : 175cm, bmi 지수 : 32.65, 결과 : 과체중\n",
      "\n",
      "마아 62 151\n",
      "\n",
      " 이름 : 마아, 몸무게 : 62kg, 키 : 151cm, bmi 지수 : 27.19, 결과 : 과체중\n",
      "\n",
      "파타 45 178\n",
      "\n",
      " 이름 : 파타, 몸무게 : 45kg, 키 : 178cm, bmi 지수 : 14.20, 결과 : 저체중\n",
      "\n",
      "타라 80 165\n",
      "\n",
      " 이름 : 타라, 몸무게 : 80kg, 키 : 165cm, bmi 지수 : 29.38, 결과 : 과체중\n",
      "\n",
      "마하 66 187\n",
      "\n",
      " 이름 : 마하, 몸무게 : 66kg, 키 : 187cm, bmi 지수 : 18.87, 결과 : 정상\n",
      "\n",
      "라카 50 182\n",
      "\n",
      " 이름 : 라카, 몸무게 : 50kg, 키 : 182cm, bmi 지수 : 15.09, 결과 : 저체중\n",
      "\n",
      "카다 47 181\n",
      "\n",
      " 이름 : 카다, 몸무게 : 47kg, 키 : 181cm, bmi 지수 : 14.35, 결과 : 저체중\n",
      "\n",
      "가가 51 144\n",
      "\n",
      " 이름 : 가가, 몸무게 : 51kg, 키 : 144cm, bmi 지수 : 24.59, 결과 : 정상\n",
      "\n",
      "파아 65 189\n",
      "\n",
      " 이름 : 파아, 몸무게 : 65kg, 키 : 189cm, bmi 지수 : 18.20, 결과 : 저체중\n",
      "\n",
      "타자 67 160\n",
      "\n",
      " 이름 : 타자, 몸무게 : 67kg, 키 : 160cm, bmi 지수 : 26.17, 결과 : 과체중\n",
      "\n",
      "카아 51 197\n",
      "\n",
      " 이름 : 카아, 몸무게 : 51kg, 키 : 197cm, bmi 지수 : 13.14, 결과 : 저체중\n",
      "\n",
      "가라 79 151\n",
      "\n",
      " 이름 : 가라, 몸무게 : 79kg, 키 : 151cm, bmi 지수 : 34.65, 결과 : 과체중\n",
      "\n",
      "자아 58 192\n",
      "\n",
      " 이름 : 자아, 몸무게 : 58kg, 키 : 192cm, bmi 지수 : 15.73, 결과 : 저체중\n",
      "\n",
      "하하 44 152\n",
      "\n",
      " 이름 : 하하, 몸무게 : 44kg, 키 : 152cm, bmi 지수 : 19.04, 결과 : 정상\n",
      "\n",
      "카다 96 170\n",
      "\n",
      " 이름 : 카다, 몸무게 : 96kg, 키 : 170cm, bmi 지수 : 33.22, 결과 : 과체중\n",
      "\n",
      "마라 84 176\n",
      "\n",
      " 이름 : 마라, 몸무게 : 84kg, 키 : 176cm, bmi 지수 : 27.12, 결과 : 과체중\n",
      "\n",
      "마아 67 179\n",
      "\n",
      " 이름 : 마아, 몸무게 : 67kg, 키 : 179cm, bmi 지수 : 20.91, 결과 : 정상\n",
      "\n",
      "차다 67 147\n",
      "\n",
      " 이름 : 차다, 몸무게 : 67kg, 키 : 147cm, bmi 지수 : 31.01, 결과 : 과체중\n",
      "\n",
      "아라 71 169\n",
      "\n",
      " 이름 : 아라, 몸무게 : 71kg, 키 : 169cm, bmi 지수 : 24.86, 결과 : 정상\n",
      "\n",
      "타라 50 154\n",
      "\n",
      " 이름 : 타라, 몸무게 : 50kg, 키 : 154cm, bmi 지수 : 21.08, 결과 : 정상\n",
      "\n",
      "바다 52 186\n",
      "\n",
      " 이름 : 바다, 몸무게 : 52kg, 키 : 186cm, bmi 지수 : 15.03, 결과 : 저체중\n",
      "\n",
      "하차 40 145\n",
      "\n",
      " 이름 : 하차, 몸무게 : 40kg, 키 : 145cm, bmi 지수 : 19.02, 결과 : 정상\n",
      "\n",
      "파사 75 161\n",
      "\n",
      " 이름 : 파사, 몸무게 : 75kg, 키 : 161cm, bmi 지수 : 28.93, 결과 : 과체중\n",
      "\n",
      "가다 66 147\n",
      "\n",
      " 이름 : 가다, 몸무게 : 66kg, 키 : 147cm, bmi 지수 : 30.54, 결과 : 과체중\n",
      "\n",
      "라하 84 177\n",
      "\n",
      " 이름 : 라하, 몸무게 : 84kg, 키 : 177cm, bmi 지수 : 26.81, 결과 : 과체중\n",
      "\n",
      "라바 53 163\n",
      "\n",
      " 이름 : 라바, 몸무게 : 53kg, 키 : 163cm, bmi 지수 : 19.95, 결과 : 정상\n",
      "\n",
      "다사 61 155\n",
      "\n",
      " 이름 : 다사, 몸무게 : 61kg, 키 : 155cm, bmi 지수 : 25.39, 결과 : 과체중\n",
      "\n",
      "아바 57 192\n",
      "\n",
      " 이름 : 아바, 몸무게 : 57kg, 키 : 192cm, bmi 지수 : 15.46, 결과 : 저체중\n",
      "\n",
      "마다 55 172\n",
      "\n",
      " 이름 : 마다, 몸무게 : 55kg, 키 : 172cm, bmi 지수 : 18.59, 결과 : 정상\n",
      "\n",
      "타카 81 159\n",
      "\n",
      " 이름 : 타카, 몸무게 : 81kg, 키 : 159cm, bmi 지수 : 32.04, 결과 : 과체중\n",
      "\n",
      "타라 74 191\n",
      "\n",
      " 이름 : 타라, 몸무게 : 74kg, 키 : 191cm, bmi 지수 : 20.28, 결과 : 정상\n",
      "\n",
      "다차 62 142\n",
      "\n",
      " 이름 : 다차, 몸무게 : 62kg, 키 : 142cm, bmi 지수 : 30.75, 결과 : 과체중\n",
      "\n",
      "가하 48 171\n",
      "\n",
      " 이름 : 가하, 몸무게 : 48kg, 키 : 171cm, bmi 지수 : 16.42, 결과 : 저체중\n",
      "\n",
      "차바 94 166\n",
      "\n",
      " 이름 : 차바, 몸무게 : 94kg, 키 : 166cm, bmi 지수 : 34.11, 결과 : 과체중\n",
      "\n",
      "나파 79 180\n",
      "\n",
      " 이름 : 나파, 몸무게 : 79kg, 키 : 180cm, bmi 지수 : 24.38, 결과 : 정상\n",
      "\n",
      "차사 80 140\n",
      "\n",
      " 이름 : 차사, 몸무게 : 80kg, 키 : 140cm, bmi 지수 : 40.82, 결과 : 과체중\n",
      "\n",
      "하다 51 196\n",
      "\n",
      " 이름 : 하다, 몸무게 : 51kg, 키 : 196cm, bmi 지수 : 13.28, 결과 : 저체중\n",
      "\n",
      "바나 54 148\n",
      "\n",
      " 이름 : 바나, 몸무게 : 54kg, 키 : 148cm, bmi 지수 : 24.65, 결과 : 정상\n",
      "\n",
      "마카 66 163\n",
      "\n",
      " 이름 : 마카, 몸무게 : 66kg, 키 : 163cm, bmi 지수 : 24.84, 결과 : 정상\n",
      "\n",
      "하나 78 169\n",
      "\n",
      " 이름 : 하나, 몸무게 : 78kg, 키 : 169cm, bmi 지수 : 27.31, 결과 : 과체중\n",
      "\n",
      "마나 85 171\n",
      "\n",
      " 이름 : 마나, 몸무게 : 85kg, 키 : 171cm, bmi 지수 : 29.07, 결과 : 과체중\n",
      "\n",
      "자마 74 152\n",
      "\n",
      " 이름 : 자마, 몸무게 : 74kg, 키 : 152cm, bmi 지수 : 32.03, 결과 : 과체중\n",
      "\n",
      "파나 41 170\n",
      "\n",
      " 이름 : 파나, 몸무게 : 41kg, 키 : 170cm, bmi 지수 : 14.19, 결과 : 저체중\n",
      "\n",
      "라나 88 149\n",
      "\n",
      " 이름 : 라나, 몸무게 : 88kg, 키 : 149cm, bmi 지수 : 39.64, 결과 : 과체중\n",
      "\n",
      "다가 73 158\n",
      "\n",
      " 이름 : 다가, 몸무게 : 73kg, 키 : 158cm, bmi 지수 : 29.24, 결과 : 과체중\n",
      "\n",
      "자아 78 163\n",
      "\n",
      " 이름 : 자아, 몸무게 : 78kg, 키 : 163cm, bmi 지수 : 29.36, 결과 : 과체중\n",
      "\n",
      "아나 47 167\n",
      "\n",
      " 이름 : 아나, 몸무게 : 47kg, 키 : 167cm, bmi 지수 : 16.85, 결과 : 저체중\n",
      "\n",
      "바마 54 144\n",
      "\n",
      " 이름 : 바마, 몸무게 : 54kg, 키 : 144cm, bmi 지수 : 26.04, 결과 : 과체중\n",
      "\n",
      "사바 47 177\n",
      "\n",
      " 이름 : 사바, 몸무게 : 47kg, 키 : 177cm, bmi 지수 : 15.00, 결과 : 저체중\n",
      "\n",
      "자타 58 156\n",
      "\n",
      " 이름 : 자타, 몸무게 : 58kg, 키 : 156cm, bmi 지수 : 23.83, 결과 : 정상\n",
      "\n",
      "차나 52 177\n",
      "\n",
      " 이름 : 차나, 몸무게 : 52kg, 키 : 177cm, bmi 지수 : 16.60, 결과 : 저체중\n",
      "\n",
      "타카 69 174\n",
      "\n",
      " 이름 : 타카, 몸무게 : 69kg, 키 : 174cm, bmi 지수 : 22.79, 결과 : 정상\n",
      "\n",
      "사자 54 178\n",
      "\n",
      " 이름 : 사자, 몸무게 : 54kg, 키 : 178cm, bmi 지수 : 17.04, 결과 : 저체중\n",
      "\n",
      "바나 49 143\n",
      "\n",
      " 이름 : 바나, 몸무게 : 49kg, 키 : 143cm, bmi 지수 : 23.96, 결과 : 정상\n",
      "\n",
      "라하 87 177\n",
      "\n",
      " 이름 : 라하, 몸무게 : 87kg, 키 : 177cm, bmi 지수 : 27.77, 결과 : 과체중\n",
      "\n",
      "마차 73 199\n",
      "\n",
      " 이름 : 마차, 몸무게 : 73kg, 키 : 199cm, bmi 지수 : 18.43, 결과 : 저체중\n",
      "\n",
      "아자 61 152\n",
      "\n",
      " 이름 : 아자, 몸무게 : 61kg, 키 : 152cm, bmi 지수 : 26.40, 결과 : 과체중\n",
      "\n",
      "마파 41 177\n",
      "\n",
      " 이름 : 마파, 몸무게 : 41kg, 키 : 177cm, bmi 지수 : 13.09, 결과 : 저체중\n",
      "\n",
      "카나 76 145\n",
      "\n",
      " 이름 : 카나, 몸무게 : 76kg, 키 : 145cm, bmi 지수 : 36.15, 결과 : 과체중\n",
      "\n",
      "마타 57 194\n",
      "\n",
      " 이름 : 마타, 몸무게 : 57kg, 키 : 194cm, bmi 지수 : 15.15, 결과 : 저체중\n",
      "\n",
      "차파 90 169\n",
      "\n",
      " 이름 : 차파, 몸무게 : 90kg, 키 : 169cm, bmi 지수 : 31.51, 결과 : 과체중\n",
      "\n",
      "가아 58 194\n",
      "\n",
      " 이름 : 가아, 몸무게 : 58kg, 키 : 194cm, bmi 지수 : 15.41, 결과 : 저체중\n",
      "\n",
      "나다 85 171\n",
      "\n",
      " 이름 : 나다, 몸무게 : 85kg, 키 : 171cm, bmi 지수 : 29.07, 결과 : 과체중\n",
      "\n",
      "다라 89 171\n",
      "\n",
      " 이름 : 다라, 몸무게 : 89kg, 키 : 171cm, bmi 지수 : 30.44, 결과 : 과체중\n",
      "\n",
      "다하 87 152\n",
      "\n",
      " 이름 : 다하, 몸무게 : 87kg, 키 : 152cm, bmi 지수 : 37.66, 결과 : 과체중\n",
      "\n",
      "차나 71 147\n",
      "\n",
      " 이름 : 차나, 몸무게 : 71kg, 키 : 147cm, bmi 지수 : 32.86, 결과 : 과체중\n",
      "\n",
      "바마 71 143\n",
      "\n",
      " 이름 : 바마, 몸무게 : 71kg, 키 : 143cm, bmi 지수 : 34.72, 결과 : 과체중\n",
      "\n",
      "자가 64 176\n",
      "\n",
      " 이름 : 자가, 몸무게 : 64kg, 키 : 176cm, bmi 지수 : 20.66, 결과 : 정상\n",
      "\n",
      "파나 75 183\n",
      "\n",
      " 이름 : 파나, 몸무게 : 75kg, 키 : 183cm, bmi 지수 : 22.40, 결과 : 정상\n",
      "\n",
      "라파 99 185\n",
      "\n",
      " 이름 : 라파, 몸무게 : 99kg, 키 : 185cm, bmi 지수 : 28.93, 결과 : 과체중\n",
      "\n",
      "라사 91 173\n",
      "\n",
      " 이름 : 라사, 몸무게 : 91kg, 키 : 173cm, bmi 지수 : 30.41, 결과 : 과체중\n",
      "\n",
      "바다 59 191\n",
      "\n",
      " 이름 : 바다, 몸무게 : 59kg, 키 : 191cm, bmi 지수 : 16.17, 결과 : 저체중\n",
      "\n",
      "자하 56 179\n",
      "\n",
      " 이름 : 자하, 몸무게 : 56kg, 키 : 179cm, bmi 지수 : 17.48, 결과 : 저체중\n",
      "\n",
      "아나 79 163\n",
      "\n",
      " 이름 : 아나, 몸무게 : 79kg, 키 : 163cm, bmi 지수 : 29.73, 결과 : 과체중\n",
      "\n",
      "마아 67 183\n",
      "\n",
      " 이름 : 마아, 몸무게 : 67kg, 키 : 183cm, bmi 지수 : 20.01, 결과 : 정상\n",
      "\n",
      "자파 99 198\n",
      "\n",
      " 이름 : 자파, 몸무게 : 99kg, 키 : 198cm, bmi 지수 : 25.25, 결과 : 과체중\n",
      "\n",
      "마사 89 154\n",
      "\n",
      " 이름 : 마사, 몸무게 : 89kg, 키 : 154cm, bmi 지수 : 37.53, 결과 : 과체중\n",
      "\n",
      "사다 90 190\n",
      "\n",
      " 이름 : 사다, 몸무게 : 90kg, 키 : 190cm, bmi 지수 : 24.93, 결과 : 정상\n",
      "\n",
      "타마 76 152\n",
      "\n",
      " 이름 : 타마, 몸무게 : 76kg, 키 : 152cm, bmi 지수 : 32.89, 결과 : 과체중\n",
      "\n",
      "바가 82 176\n",
      "\n",
      " 이름 : 바가, 몸무게 : 82kg, 키 : 176cm, bmi 지수 : 26.47, 결과 : 과체중\n",
      "\n",
      "마타 47 180\n",
      "\n",
      " 이름 : 마타, 몸무게 : 47kg, 키 : 180cm, bmi 지수 : 14.51, 결과 : 저체중\n",
      "\n",
      "마하 93 200\n",
      "\n",
      " 이름 : 마하, 몸무게 : 93kg, 키 : 200cm, bmi 지수 : 23.25, 결과 : 정상\n",
      "\n",
      "아파 100 183\n",
      "\n",
      " 이름 : 아파, 몸무게 : 100kg, 키 : 183cm, bmi 지수 : 29.86, 결과 : 과체중\n",
      "\n",
      "카가 81 178\n",
      "\n",
      " 이름 : 카가, 몸무게 : 81kg, 키 : 178cm, bmi 지수 : 25.56, 결과 : 과체중\n",
      "\n",
      "바하 96 145\n",
      "\n",
      " 이름 : 바하, 몸무게 : 96kg, 키 : 145cm, bmi 지수 : 45.66, 결과 : 과체중\n",
      "\n",
      "하마 61 185\n",
      "\n",
      " 이름 : 하마, 몸무게 : 61kg, 키 : 185cm, bmi 지수 : 17.82, 결과 : 저체중\n",
      "\n",
      "바마 58 151\n",
      "\n",
      " 이름 : 바마, 몸무게 : 58kg, 키 : 151cm, bmi 지수 : 25.44, 결과 : 과체중\n",
      "\n",
      "카사 100 179\n",
      "\n",
      " 이름 : 카사, 몸무게 : 100kg, 키 : 179cm, bmi 지수 : 31.21, 결과 : 과체중\n",
      "\n",
      "마카 67 159\n",
      "\n",
      " 이름 : 마카, 몸무게 : 67kg, 키 : 159cm, bmi 지수 : 26.50, 결과 : 과체중\n",
      "\n",
      "마나 74 195\n",
      "\n",
      " 이름 : 마나, 몸무게 : 74kg, 키 : 195cm, bmi 지수 : 19.46, 결과 : 정상\n",
      "\n",
      "하다 76 162\n",
      "\n",
      " 이름 : 하다, 몸무게 : 76kg, 키 : 162cm, bmi 지수 : 28.96, 결과 : 과체중\n",
      "\n",
      "타자 69 177\n",
      "\n",
      " 이름 : 타자, 몸무게 : 69kg, 키 : 177cm, bmi 지수 : 22.02, 결과 : 정상\n",
      "\n",
      "바라 59 149\n",
      "\n",
      " 이름 : 바라, 몸무게 : 59kg, 키 : 149cm, bmi 지수 : 26.58, 결과 : 과체중\n",
      "\n",
      "자파 58 181\n",
      "\n",
      " 이름 : 자파, 몸무게 : 58kg, 키 : 181cm, bmi 지수 : 17.70, 결과 : 저체중\n",
      "\n",
      "바나 79 154\n",
      "\n",
      " 이름 : 바나, 몸무게 : 79kg, 키 : 154cm, bmi 지수 : 33.31, 결과 : 과체중\n",
      "\n",
      "차아 91 163\n",
      "\n",
      " 이름 : 차아, 몸무게 : 91kg, 키 : 163cm, bmi 지수 : 34.25, 결과 : 과체중\n",
      "\n",
      "카라 63 179\n",
      "\n",
      " 이름 : 카라, 몸무게 : 63kg, 키 : 179cm, bmi 지수 : 19.66, 결과 : 정상\n",
      "\n",
      "가카 60 197\n",
      "\n",
      " 이름 : 가카, 몸무게 : 60kg, 키 : 197cm, bmi 지수 : 15.46, 결과 : 저체중\n",
      "\n",
      "가바 54 185\n",
      "\n",
      " 이름 : 가바, 몸무게 : 54kg, 키 : 185cm, bmi 지수 : 15.78, 결과 : 저체중\n",
      "\n",
      "바나 58 157\n",
      "\n",
      " 이름 : 바나, 몸무게 : 58kg, 키 : 157cm, bmi 지수 : 23.53, 결과 : 정상\n",
      "\n",
      "차바 57 183\n",
      "\n",
      " 이름 : 차바, 몸무게 : 57kg, 키 : 183cm, bmi 지수 : 17.02, 결과 : 저체중\n",
      "\n",
      "가사 66 163\n",
      "\n",
      " 이름 : 가사, 몸무게 : 66kg, 키 : 163cm, bmi 지수 : 24.84, 결과 : 정상\n",
      "\n",
      "바차 74 142\n",
      "\n",
      " 이름 : 바차, 몸무게 : 74kg, 키 : 142cm, bmi 지수 : 36.70, 결과 : 과체중\n",
      "\n",
      "다파 56 183\n",
      "\n",
      " 이름 : 다파, 몸무게 : 56kg, 키 : 183cm, bmi 지수 : 16.72, 결과 : 저체중\n",
      "\n",
      "아가 70 141\n",
      "\n",
      " 이름 : 아가, 몸무게 : 70kg, 키 : 141cm, bmi 지수 : 35.21, 결과 : 과체중\n",
      "\n",
      "가차 46 141\n",
      "\n",
      " 이름 : 가차, 몸무게 : 46kg, 키 : 141cm, bmi 지수 : 23.14, 결과 : 정상\n",
      "\n",
      "라아 76 140\n",
      "\n",
      " 이름 : 라아, 몸무게 : 76kg, 키 : 140cm, bmi 지수 : 38.78, 결과 : 과체중\n",
      "\n",
      "하타 70 158\n",
      "\n",
      " 이름 : 하타, 몸무게 : 70kg, 키 : 158cm, bmi 지수 : 28.04, 결과 : 과체중\n",
      "\n",
      "다사 90 177\n",
      "\n",
      " 이름 : 다사, 몸무게 : 90kg, 키 : 177cm, bmi 지수 : 28.73, 결과 : 과체중\n",
      "\n",
      "아자 54 152\n",
      "\n",
      " 이름 : 아자, 몸무게 : 54kg, 키 : 152cm, bmi 지수 : 23.37, 결과 : 정상\n",
      "\n",
      "라라 40 198\n",
      "\n",
      " 이름 : 라라, 몸무게 : 40kg, 키 : 198cm, bmi 지수 : 10.20, 결과 : 저체중\n",
      "\n",
      "하다 77 164\n",
      "\n",
      " 이름 : 하다, 몸무게 : 77kg, 키 : 164cm, bmi 지수 : 28.63, 결과 : 과체중\n",
      "\n",
      "가카 89 183\n",
      "\n",
      " 이름 : 가카, 몸무게 : 89kg, 키 : 183cm, bmi 지수 : 26.58, 결과 : 과체중\n",
      "\n",
      "자하 94 145\n",
      "\n",
      " 이름 : 자하, 몸무게 : 94kg, 키 : 145cm, bmi 지수 : 44.71, 결과 : 과체중\n",
      "\n",
      "가타 85 177\n",
      "\n",
      " 이름 : 가타, 몸무게 : 85kg, 키 : 177cm, bmi 지수 : 27.13, 결과 : 과체중\n",
      "\n",
      "나아 92 162\n",
      "\n",
      " 이름 : 나아, 몸무게 : 92kg, 키 : 162cm, bmi 지수 : 35.06, 결과 : 과체중\n",
      "\n",
      "다카 77 171\n",
      "\n",
      " 이름 : 다카, 몸무게 : 77kg, 키 : 171cm, bmi 지수 : 26.33, 결과 : 과체중\n",
      "\n",
      "다마 88 156\n",
      "\n",
      " 이름 : 다마, 몸무게 : 88kg, 키 : 156cm, bmi 지수 : 36.16, 결과 : 과체중\n",
      "\n",
      "바라 100 193\n",
      "\n",
      " 이름 : 바라, 몸무게 : 100kg, 키 : 193cm, bmi 지수 : 26.85, 결과 : 과체중\n",
      "\n",
      "하카 55 194\n",
      "\n",
      " 이름 : 하카, 몸무게 : 55kg, 키 : 194cm, bmi 지수 : 14.61, 결과 : 저체중\n",
      "\n",
      "자파 42 150\n",
      "\n",
      " 이름 : 자파, 몸무게 : 42kg, 키 : 150cm, bmi 지수 : 18.67, 결과 : 정상\n",
      "\n",
      "아자 82 155\n",
      "\n",
      " 이름 : 아자, 몸무게 : 82kg, 키 : 155cm, bmi 지수 : 34.13, 결과 : 과체중\n",
      "\n",
      "마마 46 144\n",
      "\n",
      " 이름 : 마마, 몸무게 : 46kg, 키 : 144cm, bmi 지수 : 22.18, 결과 : 정상\n",
      "\n",
      "카가 96 147\n",
      "\n",
      " 이름 : 카가, 몸무게 : 96kg, 키 : 147cm, bmi 지수 : 44.43, 결과 : 과체중\n",
      "\n",
      "마자 50 148\n",
      "\n",
      " 이름 : 마자, 몸무게 : 50kg, 키 : 148cm, bmi 지수 : 22.83, 결과 : 정상\n",
      "\n",
      "아라 47 160\n",
      "\n",
      " 이름 : 아라, 몸무게 : 47kg, 키 : 160cm, bmi 지수 : 18.36, 결과 : 저체중\n",
      "\n",
      "카라 99 176\n",
      "\n",
      " 이름 : 카라, 몸무게 : 99kg, 키 : 176cm, bmi 지수 : 31.96, 결과 : 과체중\n",
      "\n",
      "타바 56 186\n",
      "\n",
      " 이름 : 타바, 몸무게 : 56kg, 키 : 186cm, bmi 지수 : 16.19, 결과 : 저체중\n",
      "\n",
      "타아 64 173\n",
      "\n",
      " 이름 : 타아, 몸무게 : 64kg, 키 : 173cm, bmi 지수 : 21.38, 결과 : 정상\n",
      "\n",
      "바파 86 192\n",
      "\n",
      " 이름 : 바파, 몸무게 : 86kg, 키 : 192cm, bmi 지수 : 23.33, 결과 : 정상\n",
      "\n",
      "마사 78 176\n",
      "\n",
      " 이름 : 마사, 몸무게 : 78kg, 키 : 176cm, bmi 지수 : 25.18, 결과 : 과체중\n",
      "\n",
      "아파 62 193\n",
      "\n",
      " 이름 : 아파, 몸무게 : 62kg, 키 : 193cm, bmi 지수 : 16.64, 결과 : 저체중\n",
      "\n",
      "카바 91 164\n",
      "\n",
      " 이름 : 카바, 몸무게 : 91kg, 키 : 164cm, bmi 지수 : 33.83, 결과 : 과체중\n",
      "\n",
      "마타 62 161\n",
      "\n",
      " 이름 : 마타, 몸무게 : 62kg, 키 : 161cm, bmi 지수 : 23.92, 결과 : 정상\n",
      "\n",
      "마가 92 199\n",
      "\n",
      " 이름 : 마가, 몸무게 : 92kg, 키 : 199cm, bmi 지수 : 23.23, 결과 : 정상\n",
      "\n",
      "라바 50 177\n",
      "\n",
      " 이름 : 라바, 몸무게 : 50kg, 키 : 177cm, bmi 지수 : 15.96, 결과 : 저체중\n",
      "\n",
      "라라 68 158\n",
      "\n",
      " 이름 : 라라, 몸무게 : 68kg, 키 : 158cm, bmi 지수 : 27.24, 결과 : 과체중\n",
      "\n",
      "차파 40 176\n",
      "\n",
      " 이름 : 차파, 몸무게 : 40kg, 키 : 176cm, bmi 지수 : 12.91, 결과 : 저체중\n",
      "\n",
      "타나 58 147\n",
      "\n",
      " 이름 : 타나, 몸무게 : 58kg, 키 : 147cm, bmi 지수 : 26.84, 결과 : 과체중\n",
      "\n",
      "라하 83 158\n",
      "\n",
      " 이름 : 라하, 몸무게 : 83kg, 키 : 158cm, bmi 지수 : 33.25, 결과 : 과체중\n",
      "\n",
      "자바 79 167\n",
      "\n",
      " 이름 : 자바, 몸무게 : 79kg, 키 : 167cm, bmi 지수 : 28.33, 결과 : 과체중\n",
      "\n",
      "하아 53 140\n",
      "\n",
      " 이름 : 하아, 몸무게 : 53kg, 키 : 140cm, bmi 지수 : 27.04, 결과 : 과체중\n",
      "\n",
      "다라 93 185\n",
      "\n",
      " 이름 : 다라, 몸무게 : 93kg, 키 : 185cm, bmi 지수 : 27.17, 결과 : 과체중\n",
      "\n",
      "다나 78 184\n",
      "\n",
      " 이름 : 다나, 몸무게 : 78kg, 키 : 184cm, bmi 지수 : 23.04, 결과 : 정상\n",
      "\n",
      "아다 53 176\n",
      "\n",
      " 이름 : 아다, 몸무게 : 53kg, 키 : 176cm, bmi 지수 : 17.11, 결과 : 저체중\n",
      "\n",
      "타다 55 146\n",
      "\n",
      " 이름 : 타다, 몸무게 : 55kg, 키 : 146cm, bmi 지수 : 25.80, 결과 : 과체중\n",
      "\n",
      "하자 67 198\n",
      "\n",
      " 이름 : 하자, 몸무게 : 67kg, 키 : 198cm, bmi 지수 : 17.09, 결과 : 저체중\n",
      "\n",
      "사바 47 149\n",
      "\n",
      " 이름 : 사바, 몸무게 : 47kg, 키 : 149cm, bmi 지수 : 21.17, 결과 : 정상\n",
      "\n",
      "타나 83 185\n",
      "\n",
      " 이름 : 타나, 몸무게 : 83kg, 키 : 185cm, bmi 지수 : 24.25, 결과 : 정상\n",
      "\n",
      "타자 43 194\n",
      "\n",
      " 이름 : 타자, 몸무게 : 43kg, 키 : 194cm, bmi 지수 : 11.43, 결과 : 저체중\n",
      "\n",
      "파파 52 200\n",
      "\n",
      " 이름 : 파파, 몸무게 : 52kg, 키 : 200cm, bmi 지수 : 13.00, 결과 : 저체중\n",
      "\n",
      "차타 84 144\n",
      "\n",
      " 이름 : 차타, 몸무게 : 84kg, 키 : 144cm, bmi 지수 : 40.51, 결과 : 과체중\n",
      "\n",
      "가가 92 196\n",
      "\n",
      " 이름 : 가가, 몸무게 : 92kg, 키 : 196cm, bmi 지수 : 23.95, 결과 : 정상\n",
      "\n",
      "라하 47 144\n",
      "\n",
      " 이름 : 라하, 몸무게 : 47kg, 키 : 144cm, bmi 지수 : 22.67, 결과 : 정상\n",
      "\n",
      "차사 60 174\n",
      "\n",
      " 이름 : 차사, 몸무게 : 60kg, 키 : 174cm, bmi 지수 : 19.82, 결과 : 정상\n",
      "\n",
      "마타 65 179\n",
      "\n",
      " 이름 : 마타, 몸무게 : 65kg, 키 : 179cm, bmi 지수 : 20.29, 결과 : 정상\n",
      "\n",
      "다사 63 148\n",
      "\n",
      " 이름 : 다사, 몸무게 : 63kg, 키 : 148cm, bmi 지수 : 28.76, 결과 : 과체중\n",
      "\n",
      "카아 79 142\n",
      "\n",
      " 이름 : 카아, 몸무게 : 79kg, 키 : 142cm, bmi 지수 : 39.18, 결과 : 과체중\n",
      "\n",
      "라카 73 161\n",
      "\n",
      " 이름 : 라카, 몸무게 : 73kg, 키 : 161cm, bmi 지수 : 28.16, 결과 : 과체중\n",
      "\n",
      "카아 92 141\n",
      "\n",
      " 이름 : 카아, 몸무게 : 92kg, 키 : 141cm, bmi 지수 : 46.28, 결과 : 과체중\n",
      "\n",
      "라라 92 151\n",
      "\n",
      " 이름 : 라라, 몸무게 : 92kg, 키 : 151cm, bmi 지수 : 40.35, 결과 : 과체중\n",
      "\n",
      "차카 71 183\n",
      "\n",
      " 이름 : 차카, 몸무게 : 71kg, 키 : 183cm, bmi 지수 : 21.20, 결과 : 정상\n",
      "\n",
      "하타 91 146\n",
      "\n",
      " 이름 : 하타, 몸무게 : 91kg, 키 : 146cm, bmi 지수 : 42.69, 결과 : 과체중\n",
      "\n",
      "사사 82 194\n",
      "\n",
      " 이름 : 사사, 몸무게 : 82kg, 키 : 194cm, bmi 지수 : 21.79, 결과 : 정상\n",
      "\n",
      "바파 58 180\n",
      "\n",
      " 이름 : 바파, 몸무게 : 58kg, 키 : 180cm, bmi 지수 : 17.90, 결과 : 저체중\n",
      "\n",
      "카가 40 176\n",
      "\n",
      " 이름 : 카가, 몸무게 : 40kg, 키 : 176cm, bmi 지수 : 12.91, 결과 : 저체중\n",
      "\n",
      "차다 72 182\n",
      "\n",
      " 이름 : 차다, 몸무게 : 72kg, 키 : 182cm, bmi 지수 : 21.74, 결과 : 정상\n",
      "\n",
      "파가 95 163\n",
      "\n",
      " 이름 : 파가, 몸무게 : 95kg, 키 : 163cm, bmi 지수 : 35.76, 결과 : 과체중\n",
      "\n",
      "파아 82 196\n",
      "\n",
      " 이름 : 파아, 몸무게 : 82kg, 키 : 196cm, bmi 지수 : 21.35, 결과 : 정상\n",
      "\n",
      "타가 40 143\n",
      "\n",
      " 이름 : 타가, 몸무게 : 40kg, 키 : 143cm, bmi 지수 : 19.56, 결과 : 정상\n",
      "\n",
      "나나 69 176\n",
      "\n",
      " 이름 : 나나, 몸무게 : 69kg, 키 : 176cm, bmi 지수 : 22.28, 결과 : 정상\n",
      "\n",
      "카카 98 171\n",
      "\n",
      " 이름 : 카카, 몸무게 : 98kg, 키 : 171cm, bmi 지수 : 33.51, 결과 : 과체중\n",
      "\n",
      "차라 77 198\n",
      "\n",
      " 이름 : 차라, 몸무게 : 77kg, 키 : 198cm, bmi 지수 : 19.64, 결과 : 정상\n",
      "\n",
      "파바 54 140\n",
      "\n",
      " 이름 : 파바, 몸무게 : 54kg, 키 : 140cm, bmi 지수 : 27.55, 결과 : 과체중\n",
      "\n",
      "다다 96 198\n",
      "\n",
      " 이름 : 다다, 몸무게 : 96kg, 키 : 198cm, bmi 지수 : 24.49, 결과 : 정상\n",
      "\n",
      "바파 77 141\n",
      "\n",
      " 이름 : 바파, 몸무게 : 77kg, 키 : 141cm, bmi 지수 : 38.73, 결과 : 과체중\n",
      "\n",
      "자라 95 171\n",
      "\n",
      " 이름 : 자라, 몸무게 : 95kg, 키 : 171cm, bmi 지수 : 32.49, 결과 : 과체중\n",
      "\n",
      "파마 90 178\n",
      "\n",
      " 이름 : 파마, 몸무게 : 90kg, 키 : 178cm, bmi 지수 : 28.41, 결과 : 과체중\n",
      "\n",
      "다바 100 168\n",
      "\n",
      " 이름 : 다바, 몸무게 : 100kg, 키 : 168cm, bmi 지수 : 35.43, 결과 : 과체중\n",
      "\n",
      "타타 94 187\n",
      "\n",
      " 이름 : 타타, 몸무게 : 94kg, 키 : 187cm, bmi 지수 : 26.88, 결과 : 과체중\n",
      "\n",
      "타파 90 147\n",
      "\n",
      " 이름 : 타파, 몸무게 : 90kg, 키 : 147cm, bmi 지수 : 41.65, 결과 : 과체중\n",
      "\n",
      "차사 43 142\n",
      "\n",
      " 이름 : 차사, 몸무게 : 43kg, 키 : 142cm, bmi 지수 : 21.33, 결과 : 정상\n",
      "\n",
      "자마 64 194\n",
      "\n",
      " 이름 : 자마, 몸무게 : 64kg, 키 : 194cm, bmi 지수 : 17.00, 결과 : 저체중\n",
      "\n",
      "가파 89 192\n",
      "\n",
      " 이름 : 가파, 몸무게 : 89kg, 키 : 192cm, bmi 지수 : 24.14, 결과 : 정상\n",
      "\n",
      "파파 93 189\n",
      "\n",
      " 이름 : 파파, 몸무게 : 93kg, 키 : 189cm, bmi 지수 : 26.04, 결과 : 과체중\n",
      "\n",
      "라가 48 182\n",
      "\n",
      " 이름 : 라가, 몸무게 : 48kg, 키 : 182cm, bmi 지수 : 14.49, 결과 : 저체중\n",
      "\n",
      "마타 49 166\n",
      "\n",
      " 이름 : 마타, 몸무게 : 49kg, 키 : 166cm, bmi 지수 : 17.78, 결과 : 저체중\n",
      "\n",
      "다타 84 157\n",
      "\n",
      " 이름 : 다타, 몸무게 : 84kg, 키 : 157cm, bmi 지수 : 34.08, 결과 : 과체중\n",
      "\n",
      "타가 76 160\n",
      "\n",
      " 이름 : 타가, 몸무게 : 76kg, 키 : 160cm, bmi 지수 : 29.69, 결과 : 과체중\n",
      "\n",
      "하자 46 140\n",
      "\n",
      " 이름 : 하자, 몸무게 : 46kg, 키 : 140cm, bmi 지수 : 23.47, 결과 : 정상\n",
      "\n",
      "자다 45 182\n",
      "\n",
      " 이름 : 자다, 몸무게 : 45kg, 키 : 182cm, bmi 지수 : 13.59, 결과 : 저체중\n",
      "\n",
      "카타 49 162\n",
      "\n",
      " 이름 : 카타, 몸무게 : 49kg, 키 : 162cm, bmi 지수 : 18.67, 결과 : 정상\n",
      "\n",
      "카아 85 170\n",
      "\n",
      " 이름 : 카아, 몸무게 : 85kg, 키 : 170cm, bmi 지수 : 29.41, 결과 : 과체중\n",
      "\n",
      "바자 56 157\n",
      "\n",
      " 이름 : 바자, 몸무게 : 56kg, 키 : 157cm, bmi 지수 : 22.72, 결과 : 정상\n",
      "\n",
      "아라 73 180\n",
      "\n",
      " 이름 : 아라, 몸무게 : 73kg, 키 : 180cm, bmi 지수 : 22.53, 결과 : 정상\n",
      "\n",
      "라아 98 200\n",
      "\n",
      " 이름 : 라아, 몸무게 : 98kg, 키 : 200cm, bmi 지수 : 24.50, 결과 : 정상\n",
      "\n",
      "아차 55 143\n",
      "\n",
      " 이름 : 아차, 몸무게 : 55kg, 키 : 143cm, bmi 지수 : 26.90, 결과 : 과체중\n",
      "\n",
      "파라 58 149\n",
      "\n",
      " 이름 : 파라, 몸무게 : 58kg, 키 : 149cm, bmi 지수 : 26.12, 결과 : 과체중\n",
      "\n",
      "파바 44 186\n",
      "\n",
      " 이름 : 파바, 몸무게 : 44kg, 키 : 186cm, bmi 지수 : 12.72, 결과 : 저체중\n",
      "\n",
      "하자 83 197\n",
      "\n",
      " 이름 : 하자, 몸무게 : 83kg, 키 : 197cm, bmi 지수 : 21.39, 결과 : 정상\n",
      "\n",
      "아차 67 155\n",
      "\n",
      " 이름 : 아차, 몸무게 : 67kg, 키 : 155cm, bmi 지수 : 27.89, 결과 : 과체중\n",
      "\n",
      "카하 51 169\n",
      "\n",
      " 이름 : 카하, 몸무게 : 51kg, 키 : 169cm, bmi 지수 : 17.86, 결과 : 저체중\n",
      "\n",
      "하바 56 144\n",
      "\n",
      " 이름 : 하바, 몸무게 : 56kg, 키 : 144cm, bmi 지수 : 27.01, 결과 : 과체중\n",
      "\n",
      "타카 91 155\n",
      "\n",
      " 이름 : 타카, 몸무게 : 91kg, 키 : 155cm, bmi 지수 : 37.88, 결과 : 과체중\n",
      "\n",
      "차마 86 158\n",
      "\n",
      " 이름 : 차마, 몸무게 : 86kg, 키 : 158cm, bmi 지수 : 34.45, 결과 : 과체중\n",
      "\n",
      "차아 96 154\n",
      "\n",
      " 이름 : 차아, 몸무게 : 96kg, 키 : 154cm, bmi 지수 : 40.48, 결과 : 과체중\n",
      "\n",
      "다사 43 144\n",
      "\n",
      " 이름 : 다사, 몸무게 : 43kg, 키 : 144cm, bmi 지수 : 20.74, 결과 : 정상\n",
      "\n",
      "파다 70 200\n",
      "\n",
      " 이름 : 파다, 몸무게 : 70kg, 키 : 200cm, bmi 지수 : 17.50, 결과 : 저체중\n",
      "\n",
      "나아 60 153\n",
      "\n",
      " 이름 : 나아, 몸무게 : 60kg, 키 : 153cm, bmi 지수 : 25.63, 결과 : 과체중\n",
      "\n",
      "하아 69 194\n",
      "\n",
      " 이름 : 하아, 몸무게 : 69kg, 키 : 194cm, bmi 지수 : 18.33, 결과 : 저체중\n",
      "\n",
      "하가 94 185\n",
      "\n",
      " 이름 : 하가, 몸무게 : 94kg, 키 : 185cm, bmi 지수 : 27.47, 결과 : 과체중\n",
      "\n",
      "마가 51 168\n",
      "\n",
      " 이름 : 마가, 몸무게 : 51kg, 키 : 168cm, bmi 지수 : 18.07, 결과 : 저체중\n",
      "\n",
      "가파 48 150\n",
      "\n",
      " 이름 : 가파, 몸무게 : 48kg, 키 : 150cm, bmi 지수 : 21.33, 결과 : 정상\n",
      "\n",
      "바바 68 191\n",
      "\n",
      " 이름 : 바바, 몸무게 : 68kg, 키 : 191cm, bmi 지수 : 18.64, 결과 : 정상\n",
      "\n",
      "나아 48 171\n",
      "\n",
      " 이름 : 나아, 몸무게 : 48kg, 키 : 171cm, bmi 지수 : 16.42, 결과 : 저체중\n",
      "\n",
      "파아 45 140\n",
      "\n",
      " 이름 : 파아, 몸무게 : 45kg, 키 : 140cm, bmi 지수 : 22.96, 결과 : 정상\n",
      "\n",
      "바하 53 143\n",
      "\n",
      " 이름 : 바하, 몸무게 : 53kg, 키 : 143cm, bmi 지수 : 25.92, 결과 : 과체중\n",
      "\n",
      "바파 68 154\n",
      "\n",
      " 이름 : 바파, 몸무게 : 68kg, 키 : 154cm, bmi 지수 : 28.67, 결과 : 과체중\n",
      "\n",
      "차마 88 193\n",
      "\n",
      " 이름 : 차마, 몸무게 : 88kg, 키 : 193cm, bmi 지수 : 23.62, 결과 : 정상\n",
      "\n",
      "다타 88 167\n",
      "\n",
      " 이름 : 다타, 몸무게 : 88kg, 키 : 167cm, bmi 지수 : 31.55, 결과 : 과체중\n",
      "\n",
      "차나 67 200\n",
      "\n",
      " 이름 : 차나, 몸무게 : 67kg, 키 : 200cm, bmi 지수 : 16.75, 결과 : 저체중\n",
      "\n",
      "라바 76 185\n",
      "\n",
      " 이름 : 라바, 몸무게 : 76kg, 키 : 185cm, bmi 지수 : 22.21, 결과 : 정상\n",
      "\n",
      "바다 44 175\n",
      "\n",
      " 이름 : 바다, 몸무게 : 44kg, 키 : 175cm, bmi 지수 : 14.37, 결과 : 저체중\n",
      "\n",
      "가마 64 166\n",
      "\n",
      " 이름 : 가마, 몸무게 : 64kg, 키 : 166cm, bmi 지수 : 23.23, 결과 : 정상\n",
      "\n",
      "바차 60 159\n",
      "\n",
      " 이름 : 바차, 몸무게 : 60kg, 키 : 159cm, bmi 지수 : 23.73, 결과 : 정상\n",
      "\n",
      "카라 88 150\n",
      "\n",
      " 이름 : 카라, 몸무게 : 88kg, 키 : 150cm, bmi 지수 : 39.11, 결과 : 과체중\n",
      "\n",
      "자가 49 146\n",
      "\n",
      " 이름 : 자가, 몸무게 : 49kg, 키 : 146cm, bmi 지수 : 22.99, 결과 : 정상\n",
      "\n",
      "자가 75 165\n",
      "\n",
      " 이름 : 자가, 몸무게 : 75kg, 키 : 165cm, bmi 지수 : 27.55, 결과 : 과체중\n",
      "\n",
      "가아 75 144\n",
      "\n",
      " 이름 : 가아, 몸무게 : 75kg, 키 : 144cm, bmi 지수 : 36.17, 결과 : 과체중\n",
      "\n",
      "자라 75 143\n",
      "\n",
      " 이름 : 자라, 몸무게 : 75kg, 키 : 143cm, bmi 지수 : 36.68, 결과 : 과체중\n",
      "\n",
      "마자 41 167\n",
      "\n",
      " 이름 : 마자, 몸무게 : 41kg, 키 : 167cm, bmi 지수 : 14.70, 결과 : 저체중\n",
      "\n",
      "가차 81 160\n",
      "\n",
      " 이름 : 가차, 몸무게 : 81kg, 키 : 160cm, bmi 지수 : 31.64, 결과 : 과체중\n",
      "\n",
      "다바 62 167\n",
      "\n",
      " 이름 : 다바, 몸무게 : 62kg, 키 : 167cm, bmi 지수 : 22.23, 결과 : 정상\n",
      "\n",
      "카바 71 168\n",
      "\n",
      " 이름 : 카바, 몸무게 : 71kg, 키 : 168cm, bmi 지수 : 25.16, 결과 : 과체중\n",
      "\n",
      "타타 55 197\n",
      "\n",
      " 이름 : 타타, 몸무게 : 55kg, 키 : 197cm, bmi 지수 : 14.17, 결과 : 저체중\n",
      "\n",
      "카자 44 200\n",
      "\n",
      " 이름 : 카자, 몸무게 : 44kg, 키 : 200cm, bmi 지수 : 11.00, 결과 : 저체중\n",
      "\n",
      "아아 52 188\n",
      "\n",
      " 이름 : 아아, 몸무게 : 52kg, 키 : 188cm, bmi 지수 : 14.71, 결과 : 저체중\n",
      "\n",
      "사사 59 155\n",
      "\n",
      " 이름 : 사사, 몸무게 : 59kg, 키 : 155cm, bmi 지수 : 24.56, 결과 : 정상\n",
      "\n",
      "가라 71 163\n",
      "\n",
      " 이름 : 가라, 몸무게 : 71kg, 키 : 163cm, bmi 지수 : 26.72, 결과 : 과체중\n",
      "\n",
      "바사 44 189\n",
      "\n",
      " 이름 : 바사, 몸무게 : 44kg, 키 : 189cm, bmi 지수 : 12.32, 결과 : 저체중\n",
      "\n",
      "가차 84 145\n",
      "\n",
      " 이름 : 가차, 몸무게 : 84kg, 키 : 145cm, bmi 지수 : 39.95, 결과 : 과체중\n",
      "\n",
      "나자 67 190\n",
      "\n",
      " 이름 : 나자, 몸무게 : 67kg, 키 : 190cm, bmi 지수 : 18.56, 결과 : 정상\n",
      "\n",
      "차마 89 148\n",
      "\n",
      " 이름 : 차마, 몸무게 : 89kg, 키 : 148cm, bmi 지수 : 40.63, 결과 : 과체중\n",
      "\n",
      "하마 89 183\n",
      "\n",
      " 이름 : 하마, 몸무게 : 89kg, 키 : 183cm, bmi 지수 : 26.58, 결과 : 과체중\n",
      "\n",
      "다사 71 176\n",
      "\n",
      " 이름 : 다사, 몸무게 : 71kg, 키 : 176cm, bmi 지수 : 22.92, 결과 : 정상\n",
      "\n",
      "차가 97 200\n",
      "\n",
      " 이름 : 차가, 몸무게 : 97kg, 키 : 200cm, bmi 지수 : 24.25, 결과 : 정상\n",
      "\n",
      "다하 87 198\n",
      "\n",
      " 이름 : 다하, 몸무게 : 87kg, 키 : 198cm, bmi 지수 : 22.19, 결과 : 정상\n",
      "\n",
      "아가 56 170\n",
      "\n",
      " 이름 : 아가, 몸무게 : 56kg, 키 : 170cm, bmi 지수 : 19.38, 결과 : 정상\n",
      "\n",
      "사자 55 160\n",
      "\n",
      " 이름 : 사자, 몸무게 : 55kg, 키 : 160cm, bmi 지수 : 21.48, 결과 : 정상\n",
      "\n",
      "카자 77 169\n",
      "\n",
      " 이름 : 카자, 몸무게 : 77kg, 키 : 169cm, bmi 지수 : 26.96, 결과 : 과체중\n",
      "\n",
      "파하 53 168\n",
      "\n",
      " 이름 : 파하, 몸무게 : 53kg, 키 : 168cm, bmi 지수 : 18.78, 결과 : 정상\n",
      "\n",
      "아사 95 172\n",
      "\n",
      " 이름 : 아사, 몸무게 : 95kg, 키 : 172cm, bmi 지수 : 32.11, 결과 : 과체중\n",
      "\n",
      "차타 81 178\n",
      "\n",
      " 이름 : 차타, 몸무게 : 81kg, 키 : 178cm, bmi 지수 : 25.56, 결과 : 과체중\n",
      "\n",
      "사차 42 145\n",
      "\n",
      " 이름 : 사차, 몸무게 : 42kg, 키 : 145cm, bmi 지수 : 19.98, 결과 : 정상\n",
      "\n",
      "나라 52 143\n",
      "\n",
      " 이름 : 나라, 몸무게 : 52kg, 키 : 143cm, bmi 지수 : 25.43, 결과 : 과체중\n",
      "\n",
      "자아 45 145\n",
      "\n",
      " 이름 : 자아, 몸무게 : 45kg, 키 : 145cm, bmi 지수 : 21.40, 결과 : 정상\n",
      "\n",
      "다사 85 186\n",
      "\n",
      " 이름 : 다사, 몸무게 : 85kg, 키 : 186cm, bmi 지수 : 24.57, 결과 : 정상\n",
      "\n",
      "아자 77 151\n",
      "\n",
      " 이름 : 아자, 몸무게 : 77kg, 키 : 151cm, bmi 지수 : 33.77, 결과 : 과체중\n",
      "\n",
      "타카 90 190\n",
      "\n",
      " 이름 : 타카, 몸무게 : 90kg, 키 : 190cm, bmi 지수 : 24.93, 결과 : 정상\n",
      "\n",
      "아나 59 152\n",
      "\n",
      " 이름 : 아나, 몸무게 : 59kg, 키 : 152cm, bmi 지수 : 25.54, 결과 : 과체중\n",
      "\n",
      "라타 40 149\n",
      "\n",
      " 이름 : 라타, 몸무게 : 40kg, 키 : 149cm, bmi 지수 : 18.02, 결과 : 저체중\n",
      "\n",
      "하타 64 168\n",
      "\n",
      " 이름 : 하타, 몸무게 : 64kg, 키 : 168cm, bmi 지수 : 22.68, 결과 : 정상\n",
      "\n",
      "하나 92 171\n",
      "\n",
      " 이름 : 하나, 몸무게 : 92kg, 키 : 171cm, bmi 지수 : 31.46, 결과 : 과체중\n",
      "\n",
      "자타 56 198\n",
      "\n",
      " 이름 : 자타, 몸무게 : 56kg, 키 : 198cm, bmi 지수 : 14.28, 결과 : 저체중\n",
      "\n",
      "사타 80 192\n",
      "\n",
      " 이름 : 사타, 몸무게 : 80kg, 키 : 192cm, bmi 지수 : 21.70, 결과 : 정상\n",
      "\n",
      "라다 68 193\n",
      "\n",
      " 이름 : 라다, 몸무게 : 68kg, 키 : 193cm, bmi 지수 : 18.26, 결과 : 저체중\n",
      "\n",
      "타다 51 154\n",
      "\n",
      " 이름 : 타다, 몸무게 : 51kg, 키 : 154cm, bmi 지수 : 21.50, 결과 : 정상\n",
      "\n",
      "차가 57 193\n",
      "\n",
      " 이름 : 차가, 몸무게 : 57kg, 키 : 193cm, bmi 지수 : 15.30, 결과 : 저체중\n",
      "\n",
      "라카 70 171\n",
      "\n",
      " 이름 : 라카, 몸무게 : 70kg, 키 : 171cm, bmi 지수 : 23.94, 결과 : 정상\n",
      "\n",
      "파나 87 143\n",
      "\n",
      " 이름 : 파나, 몸무게 : 87kg, 키 : 143cm, bmi 지수 : 42.54, 결과 : 과체중\n",
      "\n",
      "하마 92 153\n",
      "\n",
      " 이름 : 하마, 몸무게 : 92kg, 키 : 153cm, bmi 지수 : 39.30, 결과 : 과체중\n",
      "\n",
      "마바 52 198\n",
      "\n",
      " 이름 : 마바, 몸무게 : 52kg, 키 : 198cm, bmi 지수 : 13.26, 결과 : 저체중\n",
      "\n",
      "카아 73 185\n",
      "\n",
      " 이름 : 카아, 몸무게 : 73kg, 키 : 185cm, bmi 지수 : 21.33, 결과 : 정상\n",
      "\n",
      "아라 87 176\n",
      "\n",
      " 이름 : 아라, 몸무게 : 87kg, 키 : 176cm, bmi 지수 : 28.09, 결과 : 과체중\n",
      "\n",
      "다파 71 182\n",
      "\n",
      " 이름 : 다파, 몸무게 : 71kg, 키 : 182cm, bmi 지수 : 21.43, 결과 : 정상\n",
      "\n",
      "라자 55 166\n",
      "\n",
      " 이름 : 라자, 몸무게 : 55kg, 키 : 166cm, bmi 지수 : 19.96, 결과 : 정상\n",
      "\n",
      "마가 84 153\n",
      "\n",
      " 이름 : 마가, 몸무게 : 84kg, 키 : 153cm, bmi 지수 : 35.88, 결과 : 과체중\n",
      "\n",
      "자사 79 195\n",
      "\n",
      " 이름 : 자사, 몸무게 : 79kg, 키 : 195cm, bmi 지수 : 20.78, 결과 : 정상\n",
      "\n",
      "나타 63 160\n",
      "\n",
      " 이름 : 나타, 몸무게 : 63kg, 키 : 160cm, bmi 지수 : 24.61, 결과 : 정상\n",
      "\n",
      "라사 52 194\n",
      "\n",
      " 이름 : 라사, 몸무게 : 52kg, 키 : 194cm, bmi 지수 : 13.82, 결과 : 저체중\n",
      "\n",
      "타마 62 185\n",
      "\n",
      " 이름 : 타마, 몸무게 : 62kg, 키 : 185cm, bmi 지수 : 18.12, 결과 : 저체중\n",
      "\n",
      "하자 93 152\n",
      "\n",
      " 이름 : 하자, 몸무게 : 93kg, 키 : 152cm, bmi 지수 : 40.25, 결과 : 과체중\n",
      "\n",
      "바차 50 161\n",
      "\n",
      " 이름 : 바차, 몸무게 : 50kg, 키 : 161cm, bmi 지수 : 19.29, 결과 : 정상\n",
      "\n",
      "사자 99 141\n",
      "\n",
      " 이름 : 사자, 몸무게 : 99kg, 키 : 141cm, bmi 지수 : 49.80, 결과 : 과체중\n",
      "\n",
      "바가 72 182\n",
      "\n",
      " 이름 : 바가, 몸무게 : 72kg, 키 : 182cm, bmi 지수 : 21.74, 결과 : 정상\n",
      "\n",
      "바나 88 181\n",
      "\n",
      " 이름 : 바나, 몸무게 : 88kg, 키 : 181cm, bmi 지수 : 26.86, 결과 : 과체중\n",
      "\n",
      "차파 95 143\n",
      "\n",
      " 이름 : 차파, 몸무게 : 95kg, 키 : 143cm, bmi 지수 : 46.46, 결과 : 과체중\n",
      "\n",
      "차다 69 145\n",
      "\n",
      " 이름 : 차다, 몸무게 : 69kg, 키 : 145cm, bmi 지수 : 32.82, 결과 : 과체중\n",
      "\n",
      "라가 92 178\n",
      "\n",
      " 이름 : 라가, 몸무게 : 92kg, 키 : 178cm, bmi 지수 : 29.04, 결과 : 과체중\n",
      "\n",
      "타파 97 180\n",
      "\n",
      " 이름 : 타파, 몸무게 : 97kg, 키 : 180cm, bmi 지수 : 29.94, 결과 : 과체중\n",
      "\n",
      "마파 99 183\n",
      "\n",
      " 이름 : 마파, 몸무게 : 99kg, 키 : 183cm, bmi 지수 : 29.56, 결과 : 과체중\n",
      "\n",
      "바타 97 146\n",
      "\n",
      " 이름 : 바타, 몸무게 : 97kg, 키 : 146cm, bmi 지수 : 45.51, 결과 : 과체중\n",
      "\n",
      "라타 74 143\n",
      "\n",
      " 이름 : 라타, 몸무게 : 74kg, 키 : 143cm, bmi 지수 : 36.19, 결과 : 과체중\n",
      "\n",
      "바아 40 162\n",
      "\n",
      " 이름 : 바아, 몸무게 : 40kg, 키 : 162cm, bmi 지수 : 15.24, 결과 : 저체중\n",
      "\n",
      "사타 66 158\n",
      "\n",
      " 이름 : 사타, 몸무게 : 66kg, 키 : 158cm, bmi 지수 : 26.44, 결과 : 과체중\n",
      "\n",
      "하자 92 182\n",
      "\n",
      " 이름 : 하자, 몸무게 : 92kg, 키 : 182cm, bmi 지수 : 27.77, 결과 : 과체중\n",
      "\n",
      "차바 93 171\n",
      "\n",
      " 이름 : 차바, 몸무게 : 93kg, 키 : 171cm, bmi 지수 : 31.80, 결과 : 과체중\n",
      "\n",
      "아하 42 177\n",
      "\n",
      " 이름 : 아하, 몸무게 : 42kg, 키 : 177cm, bmi 지수 : 13.41, 결과 : 저체중\n",
      "\n",
      "다타 71 190\n",
      "\n",
      " 이름 : 다타, 몸무게 : 71kg, 키 : 190cm, bmi 지수 : 19.67, 결과 : 정상\n",
      "\n",
      "바가 72 186\n",
      "\n",
      " 이름 : 바가, 몸무게 : 72kg, 키 : 186cm, bmi 지수 : 20.81, 결과 : 정상\n",
      "\n",
      "마다 52 146\n",
      "\n",
      " 이름 : 마다, 몸무게 : 52kg, 키 : 146cm, bmi 지수 : 24.39, 결과 : 정상\n",
      "\n",
      "자다 88 181\n",
      "\n",
      " 이름 : 자다, 몸무게 : 88kg, 키 : 181cm, bmi 지수 : 26.86, 결과 : 과체중\n",
      "\n",
      "라다 48 148\n",
      "\n",
      " 이름 : 라다, 몸무게 : 48kg, 키 : 148cm, bmi 지수 : 21.91, 결과 : 정상\n",
      "\n",
      "타마 40 152\n",
      "\n",
      " 이름 : 타마, 몸무게 : 40kg, 키 : 152cm, bmi 지수 : 17.31, 결과 : 저체중\n",
      "\n",
      "파타 67 151\n",
      "\n",
      " 이름 : 파타, 몸무게 : 67kg, 키 : 151cm, bmi 지수 : 29.38, 결과 : 과체중\n",
      "\n",
      "바차 70 158\n",
      "\n",
      " 이름 : 바차, 몸무게 : 70kg, 키 : 158cm, bmi 지수 : 28.04, 결과 : 과체중\n",
      "\n",
      "차자 92 172\n",
      "\n",
      " 이름 : 차자, 몸무게 : 92kg, 키 : 172cm, bmi 지수 : 31.10, 결과 : 과체중\n",
      "\n",
      "라마 96 153\n",
      "\n",
      " 이름 : 라마, 몸무게 : 96kg, 키 : 153cm, bmi 지수 : 41.01, 결과 : 과체중\n",
      "\n",
      "하나 54 141\n",
      "\n",
      " 이름 : 하나, 몸무게 : 54kg, 키 : 141cm, bmi 지수 : 27.16, 결과 : 과체중\n",
      "\n",
      "라라 60 167\n",
      "\n",
      " 이름 : 라라, 몸무게 : 60kg, 키 : 167cm, bmi 지수 : 21.51, 결과 : 정상\n",
      "\n",
      "하다 54 164\n",
      "\n",
      " 이름 : 하다, 몸무게 : 54kg, 키 : 164cm, bmi 지수 : 20.08, 결과 : 정상\n",
      "\n",
      "라파 79 155\n",
      "\n",
      " 이름 : 라파, 몸무게 : 79kg, 키 : 155cm, bmi 지수 : 32.88, 결과 : 과체중\n",
      "\n",
      "파다 47 184\n",
      "\n",
      " 이름 : 파다, 몸무게 : 47kg, 키 : 184cm, bmi 지수 : 13.88, 결과 : 저체중\n",
      "\n",
      "사하 92 186\n",
      "\n",
      " 이름 : 사하, 몸무게 : 92kg, 키 : 186cm, bmi 지수 : 26.59, 결과 : 과체중\n",
      "\n",
      "다나 99 173\n",
      "\n",
      " 이름 : 다나, 몸무게 : 99kg, 키 : 173cm, bmi 지수 : 33.08, 결과 : 과체중\n",
      "\n",
      "사타 43 188\n",
      "\n",
      " 이름 : 사타, 몸무게 : 43kg, 키 : 188cm, bmi 지수 : 12.17, 결과 : 저체중\n",
      "\n",
      "타하 88 174\n",
      "\n",
      " 이름 : 타하, 몸무게 : 88kg, 키 : 174cm, bmi 지수 : 29.07, 결과 : 과체중\n",
      "\n",
      "바바 70 175\n",
      "\n",
      " 이름 : 바바, 몸무게 : 70kg, 키 : 175cm, bmi 지수 : 22.86, 결과 : 정상\n",
      "\n",
      "아가 80 155\n",
      "\n",
      " 이름 : 아가, 몸무게 : 80kg, 키 : 155cm, bmi 지수 : 33.30, 결과 : 과체중\n",
      "\n",
      "사카 72 186\n",
      "\n",
      " 이름 : 사카, 몸무게 : 72kg, 키 : 186cm, bmi 지수 : 20.81, 결과 : 정상\n",
      "\n",
      "라타 51 141\n",
      "\n",
      " 이름 : 라타, 몸무게 : 51kg, 키 : 141cm, bmi 지수 : 25.65, 결과 : 과체중\n",
      "\n",
      "차마 74 144\n",
      "\n",
      " 이름 : 차마, 몸무게 : 74kg, 키 : 144cm, bmi 지수 : 35.69, 결과 : 과체중\n",
      "\n",
      "라자 98 197\n",
      "\n",
      " 이름 : 라자, 몸무게 : 98kg, 키 : 197cm, bmi 지수 : 25.25, 결과 : 과체중\n",
      "\n",
      "차가 71 167\n",
      "\n",
      " 이름 : 차가, 몸무게 : 71kg, 키 : 167cm, bmi 지수 : 25.46, 결과 : 과체중\n",
      "\n",
      "가파 73 187\n",
      "\n",
      " 이름 : 가파, 몸무게 : 73kg, 키 : 187cm, bmi 지수 : 20.88, 결과 : 정상\n",
      "\n",
      "마마 79 146\n",
      "\n",
      " 이름 : 마마, 몸무게 : 79kg, 키 : 146cm, bmi 지수 : 37.06, 결과 : 과체중\n",
      "\n",
      "아아 93 142\n",
      "\n",
      " 이름 : 아아, 몸무게 : 93kg, 키 : 142cm, bmi 지수 : 46.12, 결과 : 과체중\n",
      "\n",
      "마하 53 164\n",
      "\n",
      " 이름 : 마하, 몸무게 : 53kg, 키 : 164cm, bmi 지수 : 19.71, 결과 : 정상\n",
      "\n",
      "가아 42 169\n",
      "\n",
      " 이름 : 가아, 몸무게 : 42kg, 키 : 169cm, bmi 지수 : 14.71, 결과 : 저체중\n",
      "\n",
      "가차 62 142\n",
      "\n",
      " 이름 : 가차, 몸무게 : 62kg, 키 : 142cm, bmi 지수 : 30.75, 결과 : 과체중\n",
      "\n",
      "바가 80 158\n",
      "\n",
      " 이름 : 바가, 몸무게 : 80kg, 키 : 158cm, bmi 지수 : 32.05, 결과 : 과체중\n",
      "\n",
      "바자 99 149\n",
      "\n",
      " 이름 : 바자, 몸무게 : 99kg, 키 : 149cm, bmi 지수 : 44.59, 결과 : 과체중\n",
      "\n",
      "라바 51 159\n",
      "\n",
      " 이름 : 라바, 몸무게 : 51kg, 키 : 159cm, bmi 지수 : 20.17, 결과 : 정상\n",
      "\n",
      "라아 69 143\n",
      "\n",
      " 이름 : 라아, 몸무게 : 69kg, 키 : 143cm, bmi 지수 : 33.74, 결과 : 과체중\n",
      "\n",
      "타바 80 140\n",
      "\n",
      " 이름 : 타바, 몸무게 : 80kg, 키 : 140cm, bmi 지수 : 40.82, 결과 : 과체중\n",
      "\n",
      "자하 76 186\n",
      "\n",
      " 이름 : 자하, 몸무게 : 76kg, 키 : 186cm, bmi 지수 : 21.97, 결과 : 정상\n",
      "\n",
      "바나 62 171\n",
      "\n",
      " 이름 : 바나, 몸무게 : 62kg, 키 : 171cm, bmi 지수 : 21.20, 결과 : 정상\n",
      "\n",
      "바아 82 167\n",
      "\n",
      " 이름 : 바아, 몸무게 : 82kg, 키 : 167cm, bmi 지수 : 29.40, 결과 : 과체중\n",
      "\n",
      "하하 96 143\n",
      "\n",
      " 이름 : 하하, 몸무게 : 96kg, 키 : 143cm, bmi 지수 : 46.95, 결과 : 과체중\n",
      "\n",
      "아파 53 145\n",
      "\n",
      " 이름 : 아파, 몸무게 : 53kg, 키 : 145cm, bmi 지수 : 25.21, 결과 : 과체중\n",
      "\n",
      "타차 93 156\n",
      "\n",
      " 이름 : 타차, 몸무게 : 93kg, 키 : 156cm, bmi 지수 : 38.21, 결과 : 과체중\n",
      "\n",
      "가다 41 171\n",
      "\n",
      " 이름 : 가다, 몸무게 : 41kg, 키 : 171cm, bmi 지수 : 14.02, 결과 : 저체중\n",
      "\n",
      "바사 43 159\n",
      "\n",
      " 이름 : 바사, 몸무게 : 43kg, 키 : 159cm, bmi 지수 : 17.01, 결과 : 저체중\n",
      "\n",
      "자라 57 181\n",
      "\n",
      " 이름 : 자라, 몸무게 : 57kg, 키 : 181cm, bmi 지수 : 17.40, 결과 : 저체중\n",
      "\n",
      "다다 67 172\n",
      "\n",
      " 이름 : 다다, 몸무게 : 67kg, 키 : 172cm, bmi 지수 : 22.65, 결과 : 정상\n",
      "\n",
      "라카 67 162\n",
      "\n",
      " 이름 : 라카, 몸무게 : 67kg, 키 : 162cm, bmi 지수 : 25.53, 결과 : 과체중\n",
      "\n",
      "다마 71 156\n",
      "\n",
      " 이름 : 다마, 몸무게 : 71kg, 키 : 156cm, bmi 지수 : 29.17, 결과 : 과체중\n",
      "\n",
      "사카 48 186\n",
      "\n",
      " 이름 : 사카, 몸무게 : 48kg, 키 : 186cm, bmi 지수 : 13.87, 결과 : 저체중\n",
      "\n",
      "가가 58 153\n",
      "\n",
      " 이름 : 가가, 몸무게 : 58kg, 키 : 153cm, bmi 지수 : 24.78, 결과 : 정상\n",
      "\n",
      "라라 54 166\n",
      "\n",
      " 이름 : 라라, 몸무게 : 54kg, 키 : 166cm, bmi 지수 : 19.60, 결과 : 정상\n",
      "\n",
      "아타 59 171\n",
      "\n",
      " 이름 : 아타, 몸무게 : 59kg, 키 : 171cm, bmi 지수 : 20.18, 결과 : 정상\n",
      "\n",
      "바라 61 174\n",
      "\n",
      " 이름 : 바라, 몸무게 : 61kg, 키 : 174cm, bmi 지수 : 20.15, 결과 : 정상\n",
      "\n",
      "자마 75 195\n",
      "\n",
      " 이름 : 자마, 몸무게 : 75kg, 키 : 195cm, bmi 지수 : 19.72, 결과 : 정상\n",
      "\n",
      "사타 82 166\n",
      "\n",
      " 이름 : 사타, 몸무게 : 82kg, 키 : 166cm, bmi 지수 : 29.76, 결과 : 과체중\n",
      "\n",
      "라라 74 164\n",
      "\n",
      " 이름 : 라라, 몸무게 : 74kg, 키 : 164cm, bmi 지수 : 27.51, 결과 : 과체중\n",
      "\n",
      "하바 47 183\n",
      "\n",
      " 이름 : 하바, 몸무게 : 47kg, 키 : 183cm, bmi 지수 : 14.03, 결과 : 저체중\n",
      "\n",
      "나마 46 179\n",
      "\n",
      " 이름 : 나마, 몸무게 : 46kg, 키 : 179cm, bmi 지수 : 14.36, 결과 : 저체중\n",
      "\n",
      "라사 40 190\n",
      "\n",
      " 이름 : 라사, 몸무게 : 40kg, 키 : 190cm, bmi 지수 : 11.08, 결과 : 저체중\n",
      "\n",
      "마나 77 181\n",
      "\n",
      " 이름 : 마나, 몸무게 : 77kg, 키 : 181cm, bmi 지수 : 23.50, 결과 : 정상\n",
      "\n",
      "가가 52 145\n",
      "\n",
      " 이름 : 가가, 몸무게 : 52kg, 키 : 145cm, bmi 지수 : 24.73, 결과 : 정상\n",
      "\n",
      "자차 42 156\n",
      "\n",
      " 이름 : 자차, 몸무게 : 42kg, 키 : 156cm, bmi 지수 : 17.26, 결과 : 저체중\n",
      "\n",
      "차나 76 157\n",
      "\n",
      " 이름 : 차나, 몸무게 : 76kg, 키 : 157cm, bmi 지수 : 30.83, 결과 : 과체중\n",
      "\n",
      "자다 73 192\n",
      "\n",
      " 이름 : 자다, 몸무게 : 73kg, 키 : 192cm, bmi 지수 : 19.80, 결과 : 정상\n",
      "\n",
      "라다 93 194\n",
      "\n",
      " 이름 : 라다, 몸무게 : 93kg, 키 : 194cm, bmi 지수 : 24.71, 결과 : 정상\n",
      "\n",
      "나자 98 199\n",
      "\n",
      " 이름 : 나자, 몸무게 : 98kg, 키 : 199cm, bmi 지수 : 24.75, 결과 : 정상\n",
      "\n",
      "아카 84 194\n",
      "\n",
      " 이름 : 아카, 몸무게 : 84kg, 키 : 194cm, bmi 지수 : 22.32, 결과 : 정상\n",
      "\n",
      "나파 52 144\n",
      "\n",
      " 이름 : 나파, 몸무게 : 52kg, 키 : 144cm, bmi 지수 : 25.08, 결과 : 과체중\n",
      "\n",
      "타차 82 191\n",
      "\n",
      " 이름 : 타차, 몸무게 : 82kg, 키 : 191cm, bmi 지수 : 22.48, 결과 : 정상\n",
      "\n",
      "가나 75 196\n",
      "\n",
      " 이름 : 가나, 몸무게 : 75kg, 키 : 196cm, bmi 지수 : 19.52, 결과 : 정상\n",
      "\n",
      "라다 48 170\n",
      "\n",
      " 이름 : 라다, 몸무게 : 48kg, 키 : 170cm, bmi 지수 : 16.61, 결과 : 저체중\n",
      "\n",
      "자자 93 193\n",
      "\n",
      " 이름 : 자자, 몸무게 : 93kg, 키 : 193cm, bmi 지수 : 24.97, 결과 : 정상\n",
      "\n",
      "타다 48 196\n",
      "\n",
      " 이름 : 타다, 몸무게 : 48kg, 키 : 196cm, bmi 지수 : 12.49, 결과 : 저체중\n",
      "\n",
      "차가 83 197\n",
      "\n",
      " 이름 : 차가, 몸무게 : 83kg, 키 : 197cm, bmi 지수 : 21.39, 결과 : 정상\n",
      "\n",
      "자하 76 165\n",
      "\n",
      " 이름 : 자하, 몸무게 : 76kg, 키 : 165cm, bmi 지수 : 27.92, 결과 : 과체중\n",
      "\n",
      "하자 61 142\n",
      "\n",
      " 이름 : 하자, 몸무게 : 61kg, 키 : 142cm, bmi 지수 : 30.25, 결과 : 과체중\n",
      "\n",
      "하타 74 199\n",
      "\n",
      " 이름 : 하타, 몸무게 : 74kg, 키 : 199cm, bmi 지수 : 18.69, 결과 : 정상\n",
      "\n",
      "타다 83 141\n",
      "\n",
      " 이름 : 타다, 몸무게 : 83kg, 키 : 141cm, bmi 지수 : 41.75, 결과 : 과체중\n",
      "\n",
      "하카 58 150\n",
      "\n",
      " 이름 : 하카, 몸무게 : 58kg, 키 : 150cm, bmi 지수 : 25.78, 결과 : 과체중\n",
      "\n",
      "자차 72 157\n",
      "\n",
      " 이름 : 자차, 몸무게 : 72kg, 키 : 157cm, bmi 지수 : 29.21, 결과 : 과체중\n",
      "\n",
      "하가 47 156\n",
      "\n",
      " 이름 : 하가, 몸무게 : 47kg, 키 : 156cm, bmi 지수 : 19.31, 결과 : 정상\n",
      "\n",
      "마나 64 141\n",
      "\n",
      " 이름 : 마나, 몸무게 : 64kg, 키 : 141cm, bmi 지수 : 32.19, 결과 : 과체중\n",
      "\n",
      "아파 65 162\n",
      "\n",
      " 이름 : 아파, 몸무게 : 65kg, 키 : 162cm, bmi 지수 : 24.77, 결과 : 정상\n",
      "\n",
      "다아 94 185\n",
      "\n",
      " 이름 : 다아, 몸무게 : 94kg, 키 : 185cm, bmi 지수 : 27.47, 결과 : 과체중\n",
      "\n",
      "다아 68 164\n",
      "\n",
      " 이름 : 다아, 몸무게 : 68kg, 키 : 164cm, bmi 지수 : 25.28, 결과 : 과체중\n",
      "\n",
      "타파 62 147\n",
      "\n",
      " 이름 : 타파, 몸무게 : 62kg, 키 : 147cm, bmi 지수 : 28.69, 결과 : 과체중\n",
      "\n",
      "카바 57 183\n",
      "\n",
      " 이름 : 카바, 몸무게 : 57kg, 키 : 183cm, bmi 지수 : 17.02, 결과 : 저체중\n",
      "\n",
      "하하 84 151\n",
      "\n",
      " 이름 : 하하, 몸무게 : 84kg, 키 : 151cm, bmi 지수 : 36.84, 결과 : 과체중\n",
      "\n",
      "바하 92 140\n",
      "\n",
      " 이름 : 바하, 몸무게 : 92kg, 키 : 140cm, bmi 지수 : 46.94, 결과 : 과체중\n",
      "\n",
      "자마 80 183\n",
      "\n",
      " 이름 : 자마, 몸무게 : 80kg, 키 : 183cm, bmi 지수 : 23.89, 결과 : 정상\n",
      "\n",
      "카나 59 193\n",
      "\n",
      " 이름 : 카나, 몸무게 : 59kg, 키 : 193cm, bmi 지수 : 15.84, 결과 : 저체중\n",
      "\n",
      "사자 86 146\n",
      "\n",
      " 이름 : 사자, 몸무게 : 86kg, 키 : 146cm, bmi 지수 : 40.35, 결과 : 과체중\n",
      "\n",
      "나차 88 168\n",
      "\n",
      " 이름 : 나차, 몸무게 : 88kg, 키 : 168cm, bmi 지수 : 31.18, 결과 : 과체중\n",
      "\n",
      "다마 43 161\n",
      "\n",
      " 이름 : 다마, 몸무게 : 43kg, 키 : 161cm, bmi 지수 : 16.59, 결과 : 저체중\n",
      "\n",
      "사타 86 149\n",
      "\n",
      " 이름 : 사타, 몸무게 : 86kg, 키 : 149cm, bmi 지수 : 38.74, 결과 : 과체중\n",
      "\n"
     ]
    }
   ],
   "source": [
    "#info.txt 읽어서 bmi 지수 계산\n",
    "# 하사 93 154\n",
    "# 이름 : 하사\n",
    "# 몸무게 : 93kg\n",
    "# 키 : 154cm\n",
    "# bmi 지수 : 39.2 ( weight / (height/100) ** 2 )\n",
    "# 결과 : 고도 비만\n",
    "\n",
    "# with open(\"info.txt\", \"r\", encoding=\"utf-8\") as f1:\n",
    "#     for line in f1:\n",
    "#         name, weight, height = line.split()\n",
    "#         weight = int(weight)\n",
    "#         height = int(height)\n",
    "#         bmi = weight / (height / 100) ** 2\n",
    "        \n",
    "#         if bmi >= 25:\n",
    "#             result = \"과체중\"\n",
    "#         elif bmi >= 18.5:\n",
    "#             result = \"정상\"\n",
    "#         else:\n",
    "#             result = \"저체중\"\n",
    "        \n",
    "#         print(f\"이름 : {name}, 몸무게 : {weight}kg, 키 : {height}cm, bmi 지수 : {bmi:.2f}, 결과 : {result}\")\n",
    "\n",
    "with open(\"info.txt\", \"r\", encoding=\"utf-8\") as f:   \n",
    "    for info in f:\n",
    "        # print(info.strip() # 줄바꿈 제거)\n",
    "        name, weight, height = info.strip().split()\n",
    "        print(name, weight, height)\n",
    "        \n",
    "        bmi = int(weight) / (int(height) / 100) ** 2\n",
    "        \n",
    "        if bmi >= 25:\n",
    "            result = \"과체중\"\n",
    "        elif bmi >= 18.5:\n",
    "            result = \"정상\"\n",
    "        else:\n",
    "            result = \"저체중\"\n",
    "        print(\"\\n\", \"이름 : {}, 몸무게 : {}kg, 키 : {}cm, bmi 지수 : {:.2f}, 결과 : {}\".format(name, weight, height, bmi, result))\n",
    "        print()\n",
    "        \n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "11e0499a",
   "metadata": {},
   "source": [
    "### 클래스\n",
    "- 함수, 변수를 포함한 형태\n",
    "- 객체지향\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "915a56e8",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 클래스 생성\n",
    "class Calculator:\n",
    "    def __init__(self):\n",
    "        self.result = 0\n",
    "    \n",
    "    메서드    \n",
    "    def add(self, num):\n",
    "        self.result += num\n",
    "        return self.result\n",
    "\n",
    "    def sub(self, num):\n",
    "        self.result -= num\n",
    "        return self.result\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8e08c2c3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "# 사용 = 객체 생성\n",
    "calc = Calculator()\n",
    "\n",
    "# 함수 (메서드) 호출\n",
    "\n",
    "print(calc.add(10))\n",
    "\n",
    "\n",
    "print(calc.sub(5))\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d4a0210b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 클래스 생성\n",
    "class FourCal:\n",
    "    def __init__(self, first, second):\n",
    "        self.first = first\n",
    "        self.second = second\n",
    "\n",
    "    #메서드\n",
    "    def add(self):\n",
    "        return self.first + self.second\n",
    "\n",
    "    def sub(self):\n",
    "        return self.first - self.second\n",
    "    \n",
    "    def mul(self):\n",
    "        return self.first * self.second\n",
    "    \n",
    "    def div(self):\n",
    "        return self.first // self.second        \n",
    "    \n",
    "    # 주소값 같이 안나오게 하기 위해서 __str__ 메서드 오버라이딩\n",
    "    def __str__(self):\n",
    "        return f\"{self.first}, {self.second}\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "id": "1be26090",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n",
      "2\n",
      "15\n",
      "1\n",
      "5, 3\n"
     ]
    }
   ],
   "source": [
    "# __init__() 메서드는 객체가 생성될 때 자동으로 호출되는 초기화 메서드입니다. 이 메서드는 객체의 속성을 초기화하는 데 사용됩니다. 예를 들어, class FourCal: ...와 같이 클래스가 정의되어 있을 때, calc = FourCal(10, 20)과 같이 객체를 생성하면, _init__() 메서드가 자동으로 호출되어 self.first에 10이, self.second에 20이 할당됩니다. _init__() 메서드는 객체의 초기 상태를 설정하는 데 중요한 역할을 합니다.\n",
    "calc = FourCal(5, 3)\n",
    "\n",
    "print(calc.add()) # TypeError: add() takes 1 positional argument but 2 were given\n",
    "print(calc.sub())\n",
    "print(calc.mul())   \n",
    "print(calc.div())\n",
    "print(calc) # 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "id": "b2451676",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 상속\n",
    "\n",
    "class MoreFourCal(FourCal):\n",
    "    def pow(self):\n",
    "        return self.first ** self.second"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "id": "5ee8e1db",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n",
      "125\n"
     ]
    }
   ],
   "source": [
    "cale = MoreFourCal(5, 3)\n",
    "print(cale.add())\n",
    "print(cale.pow())\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7b7c780e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 오버라이딩 : 부모 클래스 메서드 재정의\n",
    "\n",
    "four1 = FourCal(4, 0)\n",
    "\n",
    "#four1.div() # ZeroDivisionError: integer division or modulo by zero\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "id": "b3d9e669",
   "metadata": {},
   "outputs": [],
   "source": [
    "# super(): 부모\n",
    "# self : 자식(객체 자신)\n",
    "\n",
    "class SafeFourCal(FourCal):\n",
    "    def div(self):\n",
    "        if self.second == 0:\n",
    "            return 0\n",
    "        else:\n",
    "            return self.first / self.second\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 169,
   "id": "e36f0113",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n"
     ]
    }
   ],
   "source": [
    "four1 = SafeFourCal(4, 0)\n",
    "print(four1.div()) # 0"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f5902fce",
   "metadata": {},
   "source": [
    "### 모듈 : 함수, 변수, 클래스 모아 놓은 파일\n",
    "\n",
    "### 패키지 : 모듈의 모임\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 192,
   "id": "227c8751",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4.0\n",
      "3.141592653589793\n",
      "2\n",
      "0.8414709848078965\n",
      "0.5403023058681398\n"
     ]
    }
   ],
   "source": [
    "# 파이썬에서 제공하는 기본 모듈\n",
    "# math가 가지고 있는 모든 설정값들을 메모리에 올림\n",
    "\n",
    "import math\n",
    "\n",
    "print(math.sqrt(16)) # math 모듈의 sqrt() 함수를 사용하여 16의 제곱근을 계산합니다. math.sqrt() 함수는 math 모듈에서 제공하는 수학 함수 중 하나로, 제곱근을 계산하는 데 사용됩니다. 예를 들어, math.sqrt(16)은 4.0을 반환합니다. math 모듈은 다양한 수학 함수를 제공하며, 이를 활용하여 복잡한 수학 연산을 수행할 수 있습니다.\n",
    "print(math.pi) # math 모듈의 pi 상수를 출력합니다. math.pi는 원주율을 나타내는 상수로, 약 3.14159의 값을 가지고 있습니다. math 모듈은 다양한 수학 상수와 함수를 제공하며, 이를 활용하여 수학적 계산을 수행할 수 있습니다. math.pi를 사용하면 원주율을 쉽게 참조할 수 있어, 원과 관련된 계산에서 유용하게 사용됩니다.\n",
    "print(math.floor(2.3)) # math 모듈의 floor() 함수를 사용하여 2.3을 내림하여 정수로 반환합니다. math.floor() 함수는 주어진 숫자를 내림하여 가장 큰 정수로 반환하는 함수입니다. 예를 들어, math.floor(2.3)은 2를 반환합니다. math 모듈은 다양한 수학 함수를 제공하며, 이를 활용하여 수학적 계산을 수행할 수 있습니다. math.floor() 함수를 사용하면 소수점을 내림하여 정수로 변환할 때 유용하게 사용됩니다.\n",
    "print(math.sin(1)) # math 모듈의 sin() 함수를 사용하여 1의 사인 값을 계산합니다. math.sin() 함수는 주어진 각도의 사인 값을 반환하는 함수입니다. 예를 들어, math.sin(1)은 0.8414709848078965를 반환합니다. math 모듈은 다양한 수학 함수를 제공하며, 이를 활용하여 삼각 함수와 관련된 계산을 수행할 수 있습니다. math.sin() 함수를 사용하면 각도의 사인 값을 쉽게 계산할 수 있어, 삼각 함수와 관련된 문제에서 유용하게 사용됩니다.\n",
    "print(math.cos(1)) # math 모듈의 cos() 함수를 사용하여 1의 코사인 값을 계산합니다. math.cos() 함수는 주어진 각도의 코사인 값을 반환하는 함수입니다. 예를 들어, math.cos(1)은 0.5403023058681398을 반환합니다. math 모듈은 다양한 수학 함수를 제공하며, 이를 활용하여 삼각 함수와 관련된 계산을 수행할 수 있습니다. math.cos() 함수를 사용하면 각도의 코사인 값을 쉽게 계산할 수 있어, 삼각 함수와 관련된 문제에서 유용하게 사용됩니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 197,
   "id": "46c2998d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n",
      "0.8414709848078965\n",
      "0.5403023058681398\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "from math import ceil, sin, cos, floor\n",
    "\n",
    "print(ceil(5.3)) # math 모듈에서 ceil() 함수를 직접 사용하여 5.3을 올림하여 정수로 반환합니다. ceil() 함수는 주어진 숫자를 올림하여 가장 작은 정수로 반환하는 함수입니다. 예를 들어, ceil(5.3)은 6을 반환합니다. math 모듈에서 필요한 함수만을 직접 가져와 사용할 수 있어, 코드의 가독성을 높이고 불필요한 네임스페이스 오염을 방지할 수 있습니다.\n",
    "print(sin(1)) # math 모듈에서 sin() 함수를 직접 사용하여 1의 사인 값을 계산합니다. sin() 함수는 주어진 각도의 사인 값을 반환하는 함수입니다. 예를 들어, sin(1)은 0.8414709848078965를 반환합니다. math 모듈에서 필요한 함수만을 직접 가져와 사용할 수 있어, 코드의 가독성을 높이고 불필요한 네임스페이스 오염을 방지할 수 있습니다.\n",
    "print(cos(1)) # math 모듈에서 cos() 함수를 직접 사용하여 1의 코사인 값을 계산합니다. cos() 함수는 주어진 각도의 코사인 값을 반환하는 함수입니다. 예를 들어, cos(1)은 0.5403023058681398을 반환합니다. math 모듈에서 필요한 함수만을 직접 가져와 사용할 수 있어, 코드의 가독성을 높이고 불필요한 네임스페이스 오염을 방지할 수 있습니다.\n",
    "print(floor(2.3)) # math 모듈에서 floor() 함수를 직접 사용하여 2.3을 내림하여 정수로 반환합니다. floor() 함수는 주어진             숫자를 내림하여 가장 큰 정수로 반환하는 함수입니다. 예를 들어, floor(2.3)은 2를 반환합니다. math 모듈에서 필요한 함수만을 직접 가져와 사용할 수 있어, 코드의 가독성을 높이고 불필요한 네임스페이스 오염을 방지할 수 있습니다 ."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 198,
   "id": "856a93e5",
   "metadata": {},
   "outputs": [],
   "source": [
    "# as : 별칭, 모듈이나 함수에 별명을 붙이는 데 사용됩니다. as 키워드를 사용하여 모듈이나 함수를 다른 이름으로 참조할 수 있습니다. 예를 들어, import math as m과 같이 math 모듈을 m이라는 별칭으로 가져올 수 있습니다. 이렇게 하면 m.sqrt(16)과 같이 math 모듈의 sqrt() 함수를 m이라는 별칭을 사용하여 호출할 수 있습니다. as 키워드는 코드의 가독성을 높이고, 긴 모듈 이름을 간단하게 사용할 때 유용하게 사용됩니다.\n",
    "\n",
    "from math import ceil as c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 188,
   "id": "0da783c3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.3849086839965148\n",
      "2\n",
      "3\n",
      "banana\n",
      "[4, 3, 1, 5, 2]\n",
      "[5, 4]\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "\n",
    "# random() : 0.0 <= x < 1.0 임의의 float 숫자\n",
    "print(random.random()) # random 모듈의 random() 함수를 사용하여 0과 1 사이의 임의의 부동 소수점 숫자를 생성합니다. random.random() 함수는 0.0 이상 1.0 미만의 난수를 반환합니다. 예를 들어, random.random()은 0.123456789와 같은 값을 반환할 수 있습니다. random 모듈은 다양한 난수 생성 함수를 제공하며, 이를 활용하여 무작위 데이터를 생성하거나 시뮬레이션을 수행할 수 있습니다. random.random() 함수를 사용하면 간단하게 난수를 생성할 수 있어, 다양한 응용 분야에서 유용하게 사용됩니다.\n",
    "print(random.randint(1, 10)) # random 모듈의 randint() 함수를\n",
    "print(random.randrange(1, 10)) # random 모듈의 randrange() 함수를 사용하여 1과 10 사이의 임의의 정수를 생성합니다. random.randrange(1, 10) 함수는 1 이상 10 미만의 정수를 반환합니다. 예를 들어, random.randrange(1, 10)은 3과 같은 값을 반환할 수 있습니다. random 모듈은 다양한 난수 생성 함수를 제공하며, 이를 활용하여 무작위 데이터를 생성하거나 시뮬레이션을 수행할 수 있습니다. random.randrange() 함수를 사용하면 특정 범위 내에서 정수를 생성할 때 유용하게 사용됩니다.\n",
    "# 주어진 리스트에서 무작위 선택\n",
    "print(random.choice(['apple', 'banana', 'cherry'])) # random 모듈의 choice() 함수를 사용하여 리스트 ['apple', 'banana', 'cherry']에서 임의\n",
    "\n",
    "list1 = [1, 2, 3, 4, 5]\n",
    "# 무작위로 썩기\n",
    "random.shuffle(list1)\n",
    "print(list1) # random 모듈의 shuffle() 함수를 사용하여 리스트 [1, 2, 3, 4, 5]의 요소들을 무작위로 섞습니다. random.shuffle() 함수는 리스트의 요소들을 제자리에서 무작위로 섞으며, 반환값은 없습니다. 예를 들어, random.shuffle([1, 2, 3, 4, 5])를 호출하면 리스트가 [3, 1, 5, 2, 4]와 같이 섞일 수 있습니다. random 모듈은 다양한 난수 생성 함수를 제공하며, 이를 활용하여 무작위 데이터를 생성하거나 시뮬레이션을 수행할 수 있습니다. random.shuffle() 함수를 사용하면 리스트의 요소들을 무작위로 섞을 때 유용하게 사용됩니다.\n",
    "\n",
    "print(random.sample(list1, k=2)) # random 모듈의 sample() 함수를 사용하여 리스트 [1, 2, 3, 4, 5]에서 임의로 2개의 요소를 선택합니다. random.sample() 함수는 주어진 리스트에서 지정된 개수만큼의 요소를 무작위로 선택하여 새로운 리스트로 반환합니다. 예를 들어, random.sample([1, 2, 3, 4, 5], 2)은 [2, 4]와 같은 값을 반환할 수 있습니다. random 모듈은 다양한 난수 생성 함수를 제공하며, 이를 활용하여 무작위 데이터를 생성하거나 시뮬레이션을 수행할 수 있습니다. random.sample() 함수를 사용하면 리스트에서 특정 개수의 요소를 무작위로 선택할 때 유용하게 사용됩니다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "48d9c2c6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "지금부터 5초 정지\n",
      "5초가 지났습니다.\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "\n",
    "print(\"지금부터 5초 정지\")\n",
    "time.sleep(5)\n",
    "print(\"5초가 지났습니다.\")    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 190,
   "id": "ff8b943d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2026-05-13 15:10:28.636020\n"
     ]
    }
   ],
   "source": [
    "import datetime\n",
    "\n",
    "now = datetime.datetime.now() # datetime 모듈의 datetime 클래스에서 now() 메서드를 사용하여 현재 날짜와 시간을 가져옵니다. now() 메서드는 현재 날짜와 시간을 나타내는 datetime 객체를 반환합니다. 예를 들어, datetime.datetime.now()는 2024-06-01 12:34:56과 같은 값을 반환할 수 있습니다. datetime 모듈은 날짜와 시간 관련 작업을 수행할 때 유용하게 사용됩니다. now() 메서드를 사용하면 현재 날짜와 시간을 쉽게 가져올 수 있어, 다양한 응용 분야에서 활용할 수 있습니다.\n",
    "print(now) # 현재 날짜와 시간을 출력합니다. now 변수에는 datetime.datetime.now()를"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 191,
   "id": "277504ab",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2026\n",
      "5\n",
      "13\n",
      "15\n",
      "10\n",
      "28\n"
     ]
    }
   ],
   "source": [
    "print(now.year) # 현재 연도를 출력합니다. now 변수는 datetime.datetime.now()로 생성된 datetime 객체를 참조하고 있으며, year 속성을 사용하여 현재 연도를 가져올 수 있습니다. 예를 들어, now.year은 2024를 반환할 수 있습니다. datetime 모듈은 날짜와 시간 관련 작업을 수행할 때 유용하게 사용됩니다. year 속성을 사용하면 현재 연도를 쉽게 가져올 수 있어, 다양한 응용 분야에서 활용할 수 있습니다.\n",
    "print(now.month) # 현재 월을 출력합니다. now 변수는 datetime.datetime.now()로 생성된 datetime 객체를 참조하고 있으며, month 속성을 사용하여 현재 월을 가져올\n",
    "print(now.day) # 현재 일을 출력합니다. now 변수는 datetime.datetime.now()로 생성된 datetime 객체를 참조하고 있으며, day 속성을 사용하여 현재 일을 가져올 수 있습니다. 예를 들어, now.day은 1을 반환할 수 있습니다. datetime 모듈은 날짜와 시간 관련 작업을 수행할 때 유용하게 사용됩니다. day 속성을 사용하면 현재 일을 쉽게 가져올 수 있어, 다양한 응용 분야에서 활용할 수 있습니다.\n",
    "print(now.hour) # 현재 시를 출력합니다. now 변수는 datetime.datetime.now()로생성된 datetime 객체를 참조하고 있으며, hour 속성을 사용하여 현재 시를 가져올 수 있습니다. 예를 들어, now.hour은 12를 반환할 수 있습니다. datetime 모듈은 날짜와 시간 관련 작업을 수행할 때 유용하게 사용됩니다. hour 속성을 사용하면 현재 시를 쉽게 가져올 수 있어, 다양한 응용 분야에서 활용할 수 있습니다.\n",
    "print(now.minute) # 현재 분을 출력합니다. now 변수는 datetime.datetime.now()로생성된 datetime 객체를 참조하고 있으며, minute 속성을 사용하여 현재 분을 가져올 수 있습니다. 예를 들어, now.minute은 34를 반환할 수 있습니다. datetime 모듈은 날짜와 시간 관련 작업을 수행할 때 유용하게 사용됩니다. minute 속성을 사용하면 현재 분을 쉽게 가져올 수 있어, 다양한 응용 분야에서 활용할 수 있습니다.\n",
    "print(now.second) # 현재 초를 출력합니다. now 변수는 datetime.datetime.now()로 생성된 datetime 객체를 참조하고 있으며, second 속성을 사용하여 현재 초를 가져올\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2ee959ff",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello\n",
      "Life is too short\n",
      "You need python\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "print('hello')\n",
    "\n",
    "# 줄단위 실행 >= 특정 행에서 실행 오류가 나는 경우\n",
    "# 파이썬 자료형\n",
    "# 정ㅅ형, 문자형, 불린형, 리스트, 튜플, 딕셔너리\n",
    "\n",
    "# \\n == 줄바꿈\n",
    "# \\t == 탭\n",
    "\n",
    "multiline = \"Life is too short\\nYou need python\"\n",
    "print(multiline)\n",
    "\n",
    "# import mod1\n",
    "# print(mod1.add(3, 4))\n",
    "# print(mod1.sub(10, 5))\n",
    "\n",
    "from mod1 import add\n",
    "print(add(3, 7))\n",
    "\n",
    "from mod import *\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b4044187",
   "metadata": {},
   "source": [
    "### 예외처리\n",
    "- 파이썬에서 오류를 처리하는 방법\n",
    "\n",
    "```\n",
    "\n",
    "try:\n",
    "    오류 발생할 가능성 구문\n",
    "except:\n",
    "    오류 발생했을 때 처리방법\n",
    "\n",
    "try:\n",
    "    오류 발생할 가능성 구문\n",
    "except IndexError as 오류변수:\n",
    "    IndexError 오류 발생했을 때 처리방법\n",
    "\n",
    "try:\n",
    "\n",
    "except IndexError as 오류변수:\n",
    "    IndexError 오류 발생했을 때 처리방법\n",
    "except ZeroDivisionError:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 205,
   "id": "04f4ca32",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "오류발생\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    f = open(\"test3.txt\", \"r\")  \n",
    "except:\n",
    "    print(\"오류발생\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "00aee51f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0으로 나눌 수 없습니다.\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    4 / 0\n",
    "except ZeroDivisionError:\n",
    "    print(\"0으로 나눌 수 없습니다.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 208,
   "id": "1e7e5828",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "division by zero\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    4 / 0\n",
    "except ZeroDivisionError as e:\n",
    "    print(e)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 209,
   "id": "621f45cf",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 나이를 입력받은 후 정수가 입력되었다면 age <= 18 미성년자입니다/ 환영합니다.\n",
    "# 입력을 확인해 주세요\n",
    "\n",
    "try:\n",
    "    age = int(input(\"나이 입력\"))    \n",
    "except:\n",
    "    print(\"입력을 확인해주세요.\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 211,
   "id": "99605d96",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 나만의 오류 작성하기\n",
    "\n",
    "class MyError(Exception):\n",
    "    pass\n",
    "\n",
    "def say_nick(nick):\n",
    "    if nick ==\"바보\":\n",
    "        raise MyError()\n",
    "    print(nick)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 214,
   "id": "79f198be",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "천사\n"
     ]
    },
    {
     "ename": "MyError",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[31m---------------------------------------------------------------------------\u001b[39m",
      "\u001b[31mMyError\u001b[39m                                   Traceback (most recent call last)",
      "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[214]\u001b[39m\u001b[32m, line 2\u001b[39m\n\u001b[32m      1\u001b[39m say_nick(\u001b[33m\"천사\"\u001b[39m)\n\u001b[32m----> \u001b[39m\u001b[32m2\u001b[39m say_nick(\u001b[33m\"바보\"\u001b[39m)\n",
      "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[211]\u001b[39m\u001b[32m, line 8\u001b[39m, in \u001b[36msay_nick\u001b[39m\u001b[34m(nick)\u001b[39m\n\u001b[32m      6\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m say_nick(nick):\n\u001b[32m      7\u001b[39m     \u001b[38;5;28;01mif\u001b[39;00m nick ==\u001b[33m\"바보\"\u001b[39m:\n\u001b[32m----> \u001b[39m\u001b[32m8\u001b[39m         \u001b[38;5;28;01mraise\u001b[39;00m MyError()\n\u001b[32m      9\u001b[39m     print(nick)\n",
      "\u001b[31mMyError\u001b[39m: "
     ]
    }
   ],
   "source": [
    "say_nick(\"천사\")\n",
    "say_nick(\"바보\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 215,
   "id": "bec3f8d3",
   "metadata": {},
   "outputs": [
    {
     "ename": "JSONDecodeError",
     "evalue": "Expecting value: line 1 column 1 (char 0)",
     "output_type": "error",
     "traceback": [
      "\u001b[31m---------------------------------------------------------------------------\u001b[39m",
      "\u001b[31mJSONDecodeError\u001b[39m                           Traceback (most recent call last)",
      "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[215]\u001b[39m\u001b[32m, line 3\u001b[39m\n\u001b[32m      1\u001b[39m \u001b[38;5;28;01mimport\u001b[39;00m json\n\u001b[32m      2\u001b[39m \u001b[38;5;28;01mwith\u001b[39;00m open(\u001b[33m\"test.json\"\u001b[39m, \u001b[33m\"r\"\u001b[39m) \u001b[38;5;28;01mas\u001b[39;00m f:\n\u001b[32m----> \u001b[39m\u001b[32m3\u001b[39m     data = json.load(f)\n\u001b[32m      4\u001b[39m     print(type(data))\n\u001b[32m      5\u001b[39m     print(data)\n\u001b[32m      6\u001b[39m \n",
      "\u001b[36mFile \u001b[39m\u001b[32m/opt/homebrew/Cellar/python@3.14/3.14.4_1/Frameworks/Python.framework/Versions/3.14/lib/python3.14/json/__init__.py:298\u001b[39m, in \u001b[36mload\u001b[39m\u001b[34m(fp, cls, object_hook, parse_float, parse_int, parse_constant, object_pairs_hook, **kw)\u001b[39m\n\u001b[32m    278\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34mload\u001b[39m(fp, *, \u001b[38;5;28mcls\u001b[39m=\u001b[38;5;28;01mNone\u001b[39;00m, object_hook=\u001b[38;5;28;01mNone\u001b[39;00m, parse_float=\u001b[38;5;28;01mNone\u001b[39;00m,\n\u001b[32m    279\u001b[39m         parse_int=\u001b[38;5;28;01mNone\u001b[39;00m, parse_constant=\u001b[38;5;28;01mNone\u001b[39;00m, object_pairs_hook=\u001b[38;5;28;01mNone\u001b[39;00m, **kw):\n\u001b[32m    280\u001b[39m \u001b[38;5;250m    \u001b[39m\u001b[33;03m\"\"\"Deserialize ``fp`` (a ``.read()``-supporting file-like object containing\u001b[39;00m\n\u001b[32m    281\u001b[39m \u001b[33;03m    a JSON document) to a Python object.\u001b[39;00m\n\u001b[32m    282\u001b[39m \n\u001b[32m   (...)\u001b[39m\u001b[32m    296\u001b[39m \u001b[33;03m    kwarg; otherwise ``JSONDecoder`` is used.\u001b[39;00m\n\u001b[32m    297\u001b[39m \u001b[33;03m    \"\"\"\u001b[39;00m\n\u001b[32m--> \u001b[39m\u001b[32m298\u001b[39m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[30;43mloads\u001b[39;49m\u001b[30;43m(\u001b[39;49m\u001b[30;43mfp\u001b[39;49m\u001b[30;43m.\u001b[39;49m\u001b[30;43mread\u001b[39;49m\u001b[30;43m(\u001b[39;49m\u001b[30;43m)\u001b[39;49m\u001b[30;43m,\u001b[39;49m\n\u001b[32m    299\u001b[39m \u001b[30;43m        \u001b[39;49m\u001b[30;43mcls\u001b[39;49m\u001b[30;43m=\u001b[39;49m\u001b[30;43mcls\u001b[39;49m\u001b[30;43m,\u001b[39;49m\u001b[30;43m \u001b[39;49m\u001b[30;43mobject_hook\u001b[39;49m\u001b[30;43m=\u001b[39;49m\u001b[30;43mobject_hook\u001b[39;49m\u001b[30;43m,\u001b[39;49m\n\u001b[32m    300\u001b[39m \u001b[30;43m        \u001b[39;49m\u001b[30;43mparse_float\u001b[39;49m\u001b[30;43m=\u001b[39;49m\u001b[30;43mparse_float\u001b[39;49m\u001b[30;43m,\u001b[39;49m\u001b[30;43m \u001b[39;49m\u001b[30;43mparse_int\u001b[39;49m\u001b[30;43m=\u001b[39;49m\u001b[30;43mparse_int\u001b[39;49m\u001b[30;43m,\u001b[39;49m\n\u001b[32m    301\u001b[39m \u001b[30;43m        \u001b[39;49m\u001b[30;43mparse_constant\u001b[39;49m\u001b[30;43m=\u001b[39;49m\u001b[30;43mparse_constant\u001b[39;49m\u001b[30;43m,\u001b[39;49m\u001b[30;43m \u001b[39;49m\u001b[30;43mobject_pairs_hook\u001b[39;49m\u001b[30;43m=\u001b[39;49m\u001b[30;43mobject_pairs_hook\u001b[39;49m\u001b[30;43m,\u001b[39;49m\u001b[30;43m \u001b[39;49m\u001b[30;43m*\u001b[39;49m\u001b[30;43m*\u001b[39;49m\u001b[30;43mkw\u001b[39;49m\u001b[30;43m)\u001b[39;49m\n",
      "\u001b[36mFile \u001b[39m\u001b[32m/opt/homebrew/Cellar/python@3.14/3.14.4_1/Frameworks/Python.framework/Versions/3.14/lib/python3.14/json/__init__.py:352\u001b[39m, in \u001b[36mloads\u001b[39m\u001b[34m(s, cls, object_hook, parse_float, parse_int, parse_constant, object_pairs_hook, **kw)\u001b[39m\n\u001b[32m    347\u001b[39m     s = s.decode(detect_encoding(s), \u001b[33m'\u001b[39m\u001b[33msurrogatepass\u001b[39m\u001b[33m'\u001b[39m)\n\u001b[32m    349\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m (\u001b[38;5;28mcls\u001b[39m \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;129;01mand\u001b[39;00m object_hook \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;129;01mand\u001b[39;00m\n\u001b[32m    350\u001b[39m         parse_int \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;129;01mand\u001b[39;00m parse_float \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;129;01mand\u001b[39;00m\n\u001b[32m    351\u001b[39m         parse_constant \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;129;01mand\u001b[39;00m object_pairs_hook \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m kw):\n\u001b[32m--> \u001b[39m\u001b[32m352\u001b[39m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[30;43m_default_decoder\u001b[39;49m\u001b[30;43m.\u001b[39;49m\u001b[30;43mdecode\u001b[39;49m\u001b[30;43m(\u001b[39;49m\u001b[30;43ms\u001b[39;49m\u001b[30;43m)\u001b[39;49m\n\u001b[32m    353\u001b[39m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mcls\u001b[39m \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[32m    354\u001b[39m     \u001b[38;5;28mcls\u001b[39m = JSONDecoder\n",
      "\u001b[36mFile \u001b[39m\u001b[32m/opt/homebrew/Cellar/python@3.14/3.14.4_1/Frameworks/Python.framework/Versions/3.14/lib/python3.14/json/decoder.py:345\u001b[39m, in \u001b[36mJSONDecoder.decode\u001b[39m\u001b[34m(self, s, _w)\u001b[39m\n\u001b[32m    340\u001b[39m \u001b[38;5;28;01mdef\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34mdecode\u001b[39m(\u001b[38;5;28mself\u001b[39m, s, _w=WHITESPACE.match):\n\u001b[32m    341\u001b[39m \u001b[38;5;250m    \u001b[39m\u001b[33;03m\"\"\"Return the Python representation of ``s`` (a ``str`` instance\u001b[39;00m\n\u001b[32m    342\u001b[39m \u001b[33;03m    containing a JSON document).\u001b[39;00m\n\u001b[32m    343\u001b[39m \n\u001b[32m    344\u001b[39m \u001b[33;03m    \"\"\"\u001b[39;00m\n\u001b[32m--> \u001b[39m\u001b[32m345\u001b[39m     obj, end = \u001b[30;43mself\u001b[39;49m\u001b[30;43m.\u001b[39;49m\u001b[30;43mraw_decode\u001b[39;49m\u001b[30;43m(\u001b[39;49m\u001b[30;43ms\u001b[39;49m\u001b[30;43m,\u001b[39;49m\u001b[30;43m \u001b[39;49m\u001b[30;43midx\u001b[39;49m\u001b[30;43m=\u001b[39;49m\u001b[30;43m_w\u001b[39;49m\u001b[30;43m(\u001b[39;49m\u001b[30;43ms\u001b[39;49m\u001b[30;43m,\u001b[39;49m\u001b[30;43m \u001b[39;49m\u001b[30;43m0\u001b[39;49m\u001b[30;43m)\u001b[39;49m\u001b[30;43m.\u001b[39;49m\u001b[30;43mend\u001b[39;49m\u001b[30;43m(\u001b[39;49m\u001b[30;43m)\u001b[39;49m\u001b[30;43m)\u001b[39;49m\n\u001b[32m    346\u001b[39m     end = _w(s, end).end()\n\u001b[32m    347\u001b[39m     \u001b[38;5;28;01mif\u001b[39;00m end != \u001b[38;5;28mlen\u001b[39m(s):\n",
      "\u001b[36mFile \u001b[39m\u001b[32m/opt/homebrew/Cellar/python@3.14/3.14.4_1/Frameworks/Python.framework/Versions/3.14/lib/python3.14/json/decoder.py:363\u001b[39m, in \u001b[36mJSONDecoder.raw_decode\u001b[39m\u001b[34m(self, s, idx)\u001b[39m\n\u001b[32m    361\u001b[39m     obj, end = \u001b[38;5;28mself\u001b[39m.scan_once(s, idx)\n\u001b[32m    362\u001b[39m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mStopIteration\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m err:\n\u001b[32m--> \u001b[39m\u001b[32m363\u001b[39m     \u001b[38;5;28;01mraise\u001b[39;00m JSONDecodeError(\u001b[33m\"\u001b[39m\u001b[33mExpecting value\u001b[39m\u001b[33m\"\u001b[39m, s, err.value) \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[32m    364\u001b[39m \u001b[38;5;28;01mreturn\u001b[39;00m obj, end\n",
      "\u001b[31mJSONDecodeError\u001b[39m: Expecting value: line 1 column 1 (char 0)"
     ]
    }
   ],
   "source": [
    "import json\n",
    "with open(\"test.json\", \"r\") as f:\n",
    "    data = json.load(f)\n",
    "    print(type(data))\n",
    "    print(data)\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b0b9ada0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'3.53.0'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# SQLite 내장 db 사용 => sql\n",
    "\n",
    "import sqlite3\n",
    "\n",
    "sqlite3.sqlite_version\n",
    "sqlite3.sqlite_version_info"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "87d44d39",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<sqlite3.Cursor at 0x10d1e55c0>"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import sqlite3\n",
    "\n",
    "conn = sqlite3.connect(\"test.db\", isolation_level=None)\n",
    "\n",
    "# cursor : 특정 테이블에 접근하는 포인터\n",
    "cursor = conn.cursor()\n",
    "\n",
    "sql = \"CREATE TABLE IF NOT EXISTS users(id interger primary key, username text,\" \\\n",
    "    \"email text, phone text, website text, regdate text)\"\n",
    "    \n",
    "cursor.execute(sql)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "dadbbb81",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'26-05-14 13:02:23'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from datetime import datetime\n",
    "\n",
    "now = datetime.now()\n",
    "\n",
    "# now의 format 변경\n",
    "nowDateTime = now.strftime('%y-%m-%d %H:%M:%S')\n",
    "nowDateTime"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "53ad6ae9",
   "metadata": {},
   "outputs": [
    {
     "ename": "IntegrityError",
     "evalue": "UNIQUE constraint failed: users.id",
     "output_type": "error",
     "traceback": [
      "\u001b[31m---------------------------------------------------------------------------\u001b[39m",
      "\u001b[31mIntegrityError\u001b[39m                            Traceback (most recent call last)",
      "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[51]\u001b[39m\u001b[32m, line 4\u001b[39m\n\u001b[32m      1\u001b[39m \u001b[38;5;66;03m# 데이터 삽입\u001b[39;00m\n\u001b[32m      2\u001b[39m sql = f\"INSERT INTO users(id, username, email, phone, website, regdate)\" \\\n\u001b[32m      3\u001b[39m \u001b[33m\"values(1, 'kk', 'kk@kk.kk', '010-0000-0000', 'https://www.kk.com', '{nowDateTime}')\"\u001b[39m\n\u001b[32m----> \u001b[39m\u001b[32m4\u001b[39m cursor.execute(sql)\n",
      "\u001b[31mIntegrityError\u001b[39m: UNIQUE constraint failed: users.id"
     ]
    }
   ],
   "source": [
    "# 데이터 삽입\n",
    "sql = f\"INSERT INTO users(id, username, email, phone, website, regdate)\" \\\n",
    "\"values(1, 'kk', 'kk@kk.kk', '010-0000-0000', 'https://www.kk.com', '{nowDateTime}')\"\n",
    "cursor.execute(sql)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "5d92f698",
   "metadata": {},
   "outputs": [
    {
     "ename": "IntegrityError",
     "evalue": "UNIQUE constraint failed: users.id",
     "output_type": "error",
     "traceback": [
      "\u001b[31m---------------------------------------------------------------------------\u001b[39m",
      "\u001b[31mIntegrityError\u001b[39m                            Traceback (most recent call last)",
      "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[52]\u001b[39m\u001b[32m, line 5\u001b[39m\n\u001b[32m      1\u001b[39m \u001b[38;5;66;03m# 데이터 삽입\u001b[39;00m\n\u001b[32m      2\u001b[39m sql = f\"INSERT INTO users(id, username, email, phone, website, regdate)\" \\\n\u001b[32m      3\u001b[39m \u001b[33m\"values(?,?,?,?,?,?)\"\u001b[39m\n\u001b[32m      4\u001b[39m \n\u001b[32m----> \u001b[39m\u001b[32m5\u001b[39m cursor.execute(sql, (\u001b[32m2\u001b[39m, \u001b[33m'kk'\u001b[39m, \u001b[33m'kk@kk.com'\u001b[39m, \u001b[33m'010-0000-0000'\u001b[39m, \u001b[33m'kk@kk.com'\u001b[39m, nowDateTime))\n",
      "\u001b[31mIntegrityError\u001b[39m: UNIQUE constraint failed: users.id"
     ]
    }
   ],
   "source": [
    "# 데이터 삽입\n",
    "sql = f\"INSERT INTO users(id, username, email, phone, website, regdate)\" \\\n",
    "\"values(?,?,?,?,?,?)\"\n",
    "\n",
    "cursor.execute(sql, (2, 'kk', 'kk@kk.com', '010-0000-0000', 'kk@kk.com', nowDateTime))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "1277e5d2",
   "metadata": {},
   "outputs": [
    {
     "ename": "IntegrityError",
     "evalue": "UNIQUE constraint failed: users.id",
     "output_type": "error",
     "traceback": [
      "\u001b[31m---------------------------------------------------------------------------\u001b[39m",
      "\u001b[31mIntegrityError\u001b[39m                            Traceback (most recent call last)",
      "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[53]\u001b[39m\u001b[32m, line 7\u001b[39m\n\u001b[32m      3\u001b[39m     (\u001b[32m4\u001b[39m, \u001b[33m'kk'\u001b[39m, \u001b[33m'kk@kk.com'\u001b[39m, \u001b[33m'010-0000-0000'\u001b[39m, \u001b[33m'kk@kk.com'\u001b[39m, nowDateTime),\n\u001b[32m      4\u001b[39m     (\u001b[32m5\u001b[39m, \u001b[33m'kk'\u001b[39m, \u001b[33m'kk@kk.com'\u001b[39m, \u001b[33m'010-0000-0000'\u001b[39m, \u001b[33m'kk@kk.com'\u001b[39m, nowDateTime)\n\u001b[32m      5\u001b[39m )\n\u001b[32m      6\u001b[39m \n\u001b[32m----> \u001b[39m\u001b[32m7\u001b[39m cursor.executemany(sql, userList)\n",
      "\u001b[31mIntegrityError\u001b[39m: UNIQUE constraint failed: users.id"
     ]
    }
   ],
   "source": [
    "userList = (\n",
    "    (3, 'kk', 'kk@kk.com', '010-0000-0000', 'kk@kk.com', nowDateTime),\n",
    "    (4, 'kk', 'kk@kk.com', '010-0000-0000', 'kk@kk.com', nowDateTime),\n",
    "    (5, 'kk', 'kk@kk.com', '010-0000-0000', 'kk@kk.com', nowDateTime)\n",
    ")\n",
    "\n",
    "cursor.executemany(sql, userList)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "636489de",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 'kk', 'kk@kk.kk', '010-0000-0000', 'https://www.kk.com', '{nowDateTime}')\n",
      "(2, 'kk', 'kk@kk.com', '010-0000-0000', 'kk@kk.com', '26-05-13 17:47:38')\n",
      "(3, 'kk', 'kk@kk.com', '010-0000-0000', 'kk@kk.com', '26-05-13 17:47:38')\n",
      "(4, 'kk', 'kk@kk.com', '010-0000-0000', 'kk@kk.com', '26-05-13 17:47:38')\n",
      "(5, 'kk', 'kk@kk.com', '010-0000-0000', 'kk@kk.com', '26-05-13 17:47:38')\n"
     ]
    }
   ],
   "source": [
    "sql = cursor.execute(\"SELECT * FROM users\")\n",
    "\n",
    "for c in cursor.fetchall():\n",
    "    print(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "b604b50e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# [13]번 셀 끝에 추가하거나 [14]번 셀 시작 시 실행\n",
    "# 만약 이전 연결에서 트랜잭션이 남아있다면 강제로 종료합니다.\n",
    "conn.rollback() # 혹은 conn.commit()\n",
    "\n",
    "# [14]번 셀 수정\n",
    "sql = \"UPDATE users SET regdate=? WHERE id=1\"\n",
    "cursor.execute(sql, (nowDateTime,))\n",
    "conn.commit() # 변경 사항을 확실히 반영하고 락을 해제합니다.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "714326dc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<sqlite3.Cursor at 0x10d1e55c0>"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sql =\"DELETE FROM users WHERE id=3\"\n",
    "cursor.execute(sql)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "6caa3191",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<sqlite3.Cursor at 0x10d1e55c0>"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sql=\"DELETE FROM users\"\n",
    "cursor.execute(sql)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".venv",
   "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.14.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}