{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. 함수 정의와 호출"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.1 인자도 반환값도 없는 함수"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "def my_func():       # 인자가 없어 ()만 입력\n",
    "    print(\"My first function!\")\n",
    "    print(\"This is a function.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My first function!\n",
      "This is a function.\n"
     ]
    }
   ],
   "source": [
    "my_func()           # 인자가 없기 때문에 함수명과 소괄호만 입력"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.2 인자는 있지만 반환값이 없는 함수"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def my_friend(friendName):     # friendName이라는 인자있음\n",
    "    print(\"{}는 나의 친구입니다.\".format(friendName))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "철수는 나의 친구입니다.\n",
      "영미는 나의 친구입니다.\n"
     ]
    }
   ],
   "source": [
    "my_friend(\"철수\")       #각각 인자를 다르게 입력해 출력결과 2개 나옴\n",
    "my_friend(\"영미\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def my_student_info(name, school_ID, phoneNumber):    # 인자가 3개\n",
    "    print(\"------------------------\")\n",
    "    print(\"- 학생이름:\", name)\n",
    "    print(\"- 학급번호:\", school_ID)\n",
    "    print(\"- 전화번호:\", phoneNumber)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "------------------------\n",
      "- 학생이름: 현아\n",
      "- 학급번호: 01\n",
      "- 전화번호: 01-235-6789\n",
      "------------------------\n",
      "- 학생이름: 진수\n",
      "- 학급번호: 02\n",
      "- 전화번호: 01-987-6543\n"
     ]
    }
   ],
   "source": [
    "my_student_info(\"현아\", \"01\", \"01-235-6789\")     # 3개의 인자대로 출력됨\n",
    "my_student_info(\"진수\", \"02\", \"01-987-6543\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.3 인자도 있고 반환값도 있는 함수"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def my_calc(x,y):\n",
    "    z = x*y\n",
    "    return z     # return 반환값"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_calc(3,4)   # 가로길이, 세로길이의 인자 두개 입력"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.4 인자에 리스트도 가능"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def my_student_info_list(student_info):      # 인자에 리스트도 가능\n",
    "    print(\"****************************\")\n",
    "    print(\"* 학생이름:\", student_info[0])\n",
    "    print(\"* 학급번호:\", student_info[1])\n",
    "    print(\"* 전화번호:\", student_info[2])\n",
    "    print(\"****************************\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "****************************\n",
      "* 학생이름: 현아\n",
      "* 학급번호: 01\n",
      "* 전화번호: 01-235-6789\n",
      "****************************\n"
     ]
    }
   ],
   "source": [
    "student1_info = [\"현아\", \"01\", \"01-235-6789\"]    # 인자가 리스트이므로 인자를 리스트로 입력해 함수출력\n",
    "my_student_info_list(student1_info)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "****************************\n",
      "* 학생이름: 진수\n",
      "* 학급번호: 02\n",
      "* 전화번호: 01-987-6543\n",
      "****************************\n"
     ]
    }
   ],
   "source": [
    "my_student_info_list([\"진수\", \"02\", \"01-987-6543\"])   #리스트를 변수에 넣어 함수의 인자로 넣을 필요없이\n",
    "                                                      #리스트를 바로 인자로 지정할 수도 있음"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. 변수의 유효 범위"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 5             # 전역변수\n",
    "\n",
    "def func1():\n",
    "    a = 1         # 지역변수 a에 1을 할당하고 출력\n",
    "    print(\"[func1] 지역 변수 a =\", a)\n",
    "\n",
    "def func2():\n",
    "    a = 2         # 지역변수 a에 2를 할당하고 출력\n",
    "    print(\"[func2] 지역 변수 a =\", a)  \n",
    "    \n",
    "def func3():      # 지역변수 a를 정의하지 않고 a를 출력      # 이때는 전역변수 a를 가져와서 출력\n",
    "    print(\"[func3] 전역 변수 a =\", a)   \n",
    "    \n",
    "def func4():      # 지역변수 a를 정의하지 않고 a를 출력  \n",
    "    global a      # (global 전역변수명) 이용해 전역변수 변경\n",
    "    a = 4         # 전역변수 변경된 값\n",
    "    print(\"[func4] 전역 변수 a =\",a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[func1] 지역 변수 a = 1\n",
      "[func2] 지역 변수 a = 2\n",
      "전역 변수 a = 5\n"
     ]
    }
   ],
   "source": [
    "func1() \n",
    "func2() \n",
    "print(\"전역 변수 a =\", a)   # 전역변수 출력 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 지역변수는 전역변수보다 먼저 참조되고 함수가 끝나면 사라짐"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[func3] 전역 변수 a = 5\n",
      "[func4] 전역 변수 a = 4\n",
      "[func3] 전역 변수 a = 4\n"
     ]
    }
   ],
   "source": [
    "func3()\n",
    "func4() \n",
    "func3() "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- func4의 호출로 전역변수 a의 값이 변경됬음을 확인"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. 람다 함수"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(lambda x : x**2) (3)     # (lambda 인자 : 인자활용 수행코드) (인자)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mySquare = lambda x : x**2   # lambda_function = lambda 인자 : 인자활용 수행코드\n",
    "mySquare(2)                  # lambda_function(인자)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "25"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mySquare(5)     # 위에서 람다함수를 변수로 할당했으니 인자만 바꿔서 출력가능"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mySimpleFunc = lambda x,y,z : 2*x + 3*y + z     # 여러 개의 인자를 쓸 경우 ,콤마로 구분\n",
    "mySimpleFunc(1,2,3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. 내장 함수"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.1 형 변환 함수"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 정수형으로 변환하는 함수 - int\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 3, -1]"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[int(0.123), int(3.5123456), int(-1.312367)]    # 실수를 정수로 변환"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1234, 5678, -9012]"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[int('1234'), int('5678'), int('-9012')]        # 문자열일 때는 실수를 표시하는 게 있어야 변환 가능"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 실수형으로 변환하는 함수 - float"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0.0, 123.0, -567.0]"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[float(0), float(123), float(-567)]               # 정수를 실수로 변환"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[10.0, 0.123, -567.89]"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[float('10'), float('0.123'), float('-567.89')]   # 문자열일 때는 실수를 표시하는 게 있어야 변환 가능"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 문자형으로 변환하는 함수 - str\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['123', '459678', '-987']"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[str(123), str(459678), str(-987)]        # 정수를 문자열로 변환"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['0.123', '345.678', '-5.987']"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[str(0.123), str(345.678), str(-5.987)]   # 실수를 문자열로 변환"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 리스트, 튜플, 세트형으로 변환하는 함수 - list, tuple, set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "list_data = ['abc', 1, 2, 'def']      # 리스트 데이터 생성\n",
    "tuple_data = ('abc', 1, 2, 'def')     # 튜플 데이터 생성\n",
    "set_data = {'abc', 1, 2, 'def'}       # 세트 데이터 생성"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[list, tuple, set]"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[type(list_data), type(tuple_data), type(set_data)]  # type함수로 각 데이터 타입 확인"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "리스트로 변환:  ['abc', 1, 2, 'def'] [1, 'abc', 2, 'def']\n"
     ]
    }
   ],
   "source": [
    "print(\"리스트로 변환: \", list(tuple_data), list(set_data))   # 튜플과 세트를 리스트로 변환"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "튜플로 변환: ('abc', 1, 2, 'def') (1, 'abc', 2, 'def')\n"
     ]
    }
   ],
   "source": [
    "print(\"튜플로 변환:\", tuple(list_data), tuple(set_data))     # 리스트와 세트를 튜플로 변환"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "세트로 변환: {1, 'abc', 2, 'def'} {1, 'abc', 2, 'def'}\n"
     ]
    }
   ],
   "source": [
    "print(\"세트로 변환:\", set(list_data), set(tuple_data))       # 리스트와 튜플을 세트로 변환"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.2  bool 함수 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- True, False 결과를 반환"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "####  bool 함수의 인자가 숫자인 경우"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bool(0)     # 인자: 숫자 0일 때만 False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bool(1)     # 인자: 양의 정수이면 True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bool(-10)   # 인자: 음의 정수이면 True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bool(5.12)  # 인자: 양의 실수이면 True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bool(-3.26) # 인자: 음의 실수이면 True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### bool 함수의 인자가 문자열인 경우\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 문자열이 있으면 True, 없으면 False\n",
    "- 문자열이 빈 문자열인지 알고 싶을 때 사용\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bool('a')    # 인자: 문자열 'a'    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bool(' ')    # 인자: 공백(공백문자열이 있는 것임)  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bool('')     # 인자: 빈문자열    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bool(None)   # 인자: None     "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 리스트, 튜플, 세트를 인자로 bool 함수 호출"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- 항목이 있으면 Ture, 없으면 False\n",
    "- 데이터에서 항목이 있는지 없는지 검사할 때 유용"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myFriends = []     # 인자: 항목이 없는 빈 리스트 \n",
    "bool(myFriends) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myFriends = ['James', 'Robert', 'Lisa', 'Mary']  # 인자: 항목이 있는 리스트\n",
    "bool(myFriends)    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myNum = ()        # 인자: 항목이 없는 빈 튜플\n",
    "bool(myNum)  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myNum = (1,2,3)   # 인자: 항목이 있는 튜플\n",
    "bool(myNum)  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mySetA = {}      # 인자: 항목이 없는 빈 세트\n",
    "bool(mySetA) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mySetA = {10,20,30}   # 인자: 항목이 있는 세트\n",
    "bool(mySetA) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### bool 함수의 활용"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_name(name):\n",
    "    if bool(name):      # name인자에 문자열이 있으면 \n",
    "        print(\"입력된 이름:\", name)    # 이름을 출력\n",
    "    else:\n",
    "        print(\"입력된 이름이 없습니다.\")    # 없으면 입력된 문자열이 없다고 출력"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "입력된 이름: James\n"
     ]
    }
   ],
   "source": [
    "print_name(\"James\")    # 문자열이 있는 경우"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "입력된 이름이 없습니다.\n"
     ]
    }
   ],
   "source": [
    "print_name(\"\")         # 문자열이 없는 경우"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.3 min, max"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 99.5]"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myNum = [10, 5, 12, 0, 3.5, 99.5, 42]  # 숫자 리스트에서 최소, 최대 구하기\n",
    "[min(myNum), max(myNum)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['a', 'z']"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myStr = 'zxyabc'                       # 문자열 리스트에서도 최소, 최대 구할 수 있음\n",
    "[min(myStr), max(myStr)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 99.5]"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myNum = (10, 5, 12, 0, 3.5, 99.5, 42)  # 튜플에서 최소, 최대 구하기\n",
    "[min(myNum), max(myNum)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Abc', 'efg']"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myNum = {\"Abc\", \"abc\", \"bcd\", \"efg\"}   # 세트에서 최소, 최대 구하기\n",
    "[min(myNum), max(myNum)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.4 abs, sum"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[10, 10]"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[abs(10), abs(-10)]      # 절댓값"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "55"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sumList = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]      # 리스트, 튜플, 세트 데이터의 모든 항목을 더해 전체 합을 출력\n",
    "sum(sumList)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.5 len"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(\"ab cd\")    # 문자열은 공백을 포함한 문자 길이(개수)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len([1, 2, 3, 4, 5, 6, 7, 8])     # 리스트는 항목의 길이(개수)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len((1, 2, 3, 4, 5))              # 튜플은 항목의 길이(개수)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len({'a', 'b', 'c', 'd'})         # 세트"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len({1:\"Thomas\", 2:\"Edward\", 3:\"Henry\"})    # 딕셔너리는 항목의 길이(개수)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5. 내장 함수의 활용"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "총점:350, 평균:87.5\n"
     ]
    }
   ],
   "source": [
    "scores = [90, 80, 95, 85] # 과목별 시험 점수\n",
    "\n",
    "score_sum = 0                      # 총점 계산을 위한 초깃값 설정\n",
    "subject_num = 0                    # 과목수 계산을 위한 초깃값 설정\n",
    "for score in scores:\n",
    "    score_sum = score_sum + score  # 과목별 점수 모두 더하기\n",
    "    subject_num = subject_num + 1  # 과목수 계산\n",
    "    \n",
    "average = score_sum / subject_num  # 평균(총점 / 과목수) 구하기\n",
    "\n",
    "print(\"총점:{0}, 평균:{1}\".format(score_sum,average))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "총점:350, 평균:87.5\n"
     ]
    }
   ],
   "source": [
    "scores = [90, 80, 95, 85]  # 과목별 시험 점수\n",
    "\n",
    "print(\"총점:{0}, 평균:{1}\".format(sum(scores), sum(scores)/len(scores)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "최하 점수:80, 최고 점수:95\n"
     ]
    }
   ],
   "source": [
    "print(\"최하 점수:{0}, 최고 점수:{1}\".format(min(scores), max(scores)))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}