python_numpy_re.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "37783ab8",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "# Part 2. 데이터 과학을 위한 파이썬"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "21730887",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "# 2. 파이썬의 기초"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b252ba93",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## 2.1 자료형"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2f50dd33",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "- 수치형(numerical) : 숫자 형태로 이루어진 수를 나타내는 자료형을 말한다. 일상에서 늘 사용하기 때문에 익숙하다. 자주 쓰이는 수치형 자료는 정수와 부동소수점이 있다.\n",
    "\n",
    "- 부동소수점 : 소숫점이 움직이는 숫자. 3.14와 같이 소수점이 찍혀 있는 숫자이다. 부동이라는 것은 floating으로 떠서 움직일 수 있음. 고정되어 있지 않다는 것이다\n",
    "\n",
    "- 문자열 : 문자의 나열을 뜻하는데 문자들의 집합이다. string이라고 불린다"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "280497e9",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "123\n",
      "7777\n"
     ]
    }
   ],
   "source": [
    "## 정수형 자료형 출력\n",
    "\n",
    "print(123)\n",
    "print(7777)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "6db08c18",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.14\n",
      "-1.2\n"
     ]
    }
   ],
   "source": [
    "## 부동소수점 자료형 출력\n",
    "\n",
    "print(3.14)\n",
    "print(-1.2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "a4bc64a6",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "777\n",
      "3.14\n"
     ]
    }
   ],
   "source": [
    "## 정수형, 부동소수점 자료형 출력\n",
    "\n",
    "print(777)\n",
    "print(3.14)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "5fde3ac7",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n",
      "<class 'float'>\n"
     ]
    }
   ],
   "source": [
    "## type() 함수 출력\n",
    "\n",
    "print(type(777))\n",
    "print(type(3.14))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "1b051b13",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Why Learn Python\n",
      "파이썬을 배워야 하는 이유\n"
     ]
    }
   ],
   "source": [
    "## 문자열 출력(큰따옴표)\n",
    "\n",
    "print(\"Why Learn Python\")\n",
    "print(\"파이썬을 배워야 하는 이유\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "2f8328cb",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a\n",
      "Python is Great for Biginners\n"
     ]
    }
   ],
   "source": [
    "## 문자열 출력(작은따옴표)\n",
    "print('a')\n",
    "print('Python is Great for Biginners')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "410f372c",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "아기 상어 뚜 루루 뚜루\n",
      "귀여운 뚜 루루 뚜루\n",
      "바닷속 뚜 루루 뚜루\n",
      "아기 상어 !\n",
      "엄마 상어 뚜 루루 뚜루\n",
      "어여쁜 뚜 루루 뚜루\n",
      "바닷속 뚜 루루 뚜루\n",
      "엄마 상어\n"
     ]
    }
   ],
   "source": [
    "## 문자열 출력(큰따옴표)\n",
    "\n",
    "print(\"\"\"아기 상어 뚜 루루 뚜루\n",
    "귀여운 뚜 루루 뚜루\n",
    "바닷속 뚜 루루 뚜루\n",
    "아기 상어 !\n",
    "엄마 상어 뚜 루루 뚜루\n",
    "어여쁜 뚜 루루 뚜루\n",
    "바닷속 뚜 루루 뚜루\n",
    "엄마 상어\"\"\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "38c50439",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "아빠 상어 뚜 루루 뚜루\n",
      "힘이 쎈 뚜 루루 뚜루\n",
      "바닷속 뚜 루루 뚜루\n",
      "아빠 상어 !\n",
      "할머니 상어 뚜 루루 뚜루\n",
      "자상한 뚜 루루 뚜루\n",
      "바닷속 뚜 루루 뚜루\n",
      "할머니 상어 !\n"
     ]
    }
   ],
   "source": [
    "## 문자열 출력(작은 따옴표)\n",
    "\n",
    "print('''아빠 상어 뚜 루루 뚜루\n",
    "힘이 쎈 뚜 루루 뚜루\n",
    "바닷속 뚜 루루 뚜루\n",
    "아빠 상어 !\n",
    "할머니 상어 뚜 루루 뚜루\n",
    "자상한 뚜 루루 뚜루\n",
    "바닷속 뚜 루루 뚜루\n",
    "할머니 상어 !''')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "819a29aa",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## 2.2 변수"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f496a9e0",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "- 변수 : 값(Value)를 저장하는 공간. 숫자 문자 등 모든 자료형 저장 가능. 변수에는 기본적으로 하나의 값만 넣을 수 있다."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "88ea0f9a",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "1번만 봐도 변수와 값, 정말 쉽죠 ?\n",
      "Tea\n"
     ]
    }
   ],
   "source": [
    "## 변수 출력\n",
    "\n",
    "a = 1\n",
    "b = '1번만 봐도 변수와 값, 정말 쉽죠 ?'\n",
    "c = \"Tea\"\n",
    "print(a)\n",
    "print(b)\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "8585fe4e",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n"
     ]
    }
   ],
   "source": [
    "## 숫자 변수형 - count, cnt, counter\n",
    "\n",
    "cnt = 7\n",
    "print(cnt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "5d6a5432",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "자주 사용되는 문자열 변수명 str, string\n"
     ]
    }
   ],
   "source": [
    "## 문자열 변수명 - string, str\n",
    "\n",
    "str = \"자주 사용되는 문자열 변수명 str, string\"\n",
    "print(str)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fd84fb2e",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## 2.3 예약어"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0808b735",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "- 예약어 : 변수 지정 불가능함. 예약어 유의 사용"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "8c5a7426",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']\n"
     ]
    }
   ],
   "source": [
    "## 예약어 출력\n",
    "import keyword         # keyword라는 모듈 불러오기\n",
    "print(keyword.kwlist)  # 출력"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "59c5f5e6",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## 2.4 식별자"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f3f38994",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "- 식별자 : 무언가를 식별하기 위해 변수 또는 함수에 주어진 이름을 말한다\n",
    "\n",
    "### <변수 또는 함수의 이름을 지정하기 전에 식별자로 지정할 수 있는 규칙>\n",
    "- 첫 문자는 알파벳 문자이거나 언더바(_)여야 한다\n",
    "- 숫자로 시작할 수 없다\n",
    "- 특수문자는 언더바(_)만 가능하다.\n",
    "- 대/소문자를 구분한다. 예를 들어 Hello != hello\n",
    "- 예약어 사용 불가\n",
    "- 공백을 포함할 수 없다"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3da6ecf5",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## 2.5 리터럴 상수"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ac35da6e",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "리터럴 상수 : 1.77 같은 숫자 또는 \"Hello Python World\"와 같은 문자열을 말한다. 상수는 한번 지정되면 변하지 않는 값이다. 변수와 반대 개념"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "74f7a647",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## 2.6 주석"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d5bf4d67",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "- 주석 : 프로그램에 영향을 주지 않는 # 뒤에 따라오는 짧은 문장이다"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "68f7924c",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World\n"
     ]
    }
   ],
   "source": [
    "## 간단한 문자열 출력합니다\n",
    "print(\"Hello World\")   # 문자열 출력"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7a96f4b7",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## 2.7 표현식과 문장"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "23ee6bbd",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## 2.8 연산자와 피연산자"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "7dddb551",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "1\n",
      "6\n",
      "2.0\n",
      "2\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "## 연산자, 피연산자, 수식 출력\n",
    "\n",
    "print(1 + 1)\n",
    "print(2 - 1)\n",
    "print(3 * 2)\n",
    "print(4 / 2)\n",
    "print(12 % 5)\n",
    "\n",
    "print(2 > 1)\n",
    "print(3 < 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "fde01ce2",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "True\n",
      "True\n",
      "27\n",
      "8\n"
     ]
    }
   ],
   "source": [
    "print(1 <= 4)\n",
    "print(1 >= 5)\n",
    "print(7 == 7)\n",
    "print(3 != 5)\n",
    "\n",
    "print(3 ** 3)\n",
    "print(1 + (2 + 5))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "766d5795",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## 2.9 문자열"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "30ac7484",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "579\n",
      "123456\n"
     ]
    }
   ],
   "source": [
    "## 문자열 연산자 출력\n",
    "# 숫자\n",
    "number1 = 123\n",
    "number2 = 456\n",
    "print(number1 + number2)\n",
    "\n",
    "# 문자열\n",
    "number1 = '123'\n",
    "number2 = '456'\n",
    "print(number1 + number2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0411e776",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### 반복 연산자"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "ce5a78a0",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "프로그래밍을 배우고자 하는 입문자들에게 ~ 프로그래밍을 배우고자 하는 입문자들에게 ~ 프로그래밍을 배우고자 하는 입문자들에게 ~ \n",
      "파이썬은 배우기 쉽다 !파이썬은 배우기 쉽다 !파이썬은 배우기 쉽다 !\n"
     ]
    }
   ],
   "source": [
    "## 문열 반복 연산자 출력\n",
    "# *(곱셈) 연산자로 문자열을 반복한다\n",
    "print(\"프로그래밍을 배우고자 하는 입문자들에게 ~ \" * 3)\n",
    "print(3 * \"파이썬은 배우기 쉽다 !\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "888f6642",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### 길이 구하기"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "6eac3194",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "8\n"
     ]
    }
   ],
   "source": [
    "## 문자열 길이 출력\n",
    "im = \"HAPPY\"\n",
    "print(len(im))\n",
    "print(len(\"쉽게배우는파이썬\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "62c79ed5",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "쉽게배우는\n",
      "파이썬\n",
      "Hello\n",
      "Python\n"
     ]
    }
   ],
   "source": [
    "## 문자열 슬라이스 출력 - 1\n",
    "# a라는 이름의 변수에 문자열을 대입합니다\n",
    "a = \"쉽게배우는파이썬\"\n",
    "\n",
    "# 시작과 끝의 범위를 지정합니다\n",
    "print(a[0:5])\n",
    "print(a[5:8])\n",
    "print(\"HelloPython\"[0:5])\n",
    "print(\"HelloPython\"[5:11])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "ed8ddb16",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "쉽게배우는\n",
      "파이썬\n",
      "Python\n",
      "Hello\n"
     ]
    }
   ],
   "source": [
    "## 문자열 슬라이스 출력 - 2\n",
    "# a라는 이름의 변수에 문자열을 대입합니다\n",
    "a = \"쉽게배우는파이썬\"\n",
    "\n",
    "# 한쪽 숫자를 생략합니다\n",
    "print(a[:5])\n",
    "print(a[5:])\n",
    "print(\"HelloPython\"[5:])\n",
    "print(\"HelloPython\"[:5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "8bd55185",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "kelloPython\n"
     ]
    }
   ],
   "source": [
    "## 슬라이싱을 활용한 문자열 연결 출력\n",
    "python = \"HelloPython\"\n",
    "python_new = \"k\" + python[1:]\n",
    "print(python_new)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3eb0cd06",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## 2.10 불리언 연산자"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "109ebc22",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "## 불리언 연산자 출력\n",
    "# 축구 vs 야구\n",
    "footbalLove = True     # 축구를 좋아합니다\n",
    "footbalHate = False    # 축구를 싫어합니다\n",
    "baseballLove = True    # 야구를 좋아합니다\n",
    "baseballHate = False   # 야구를 싫어합니다"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "c9149e5c",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "False\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# 지현 - 축구(True) 야구(False)\n",
    "print(footbalLove and baseballHate)  # False\n",
    "print(baseballHate and footbalLove)  # False\n",
    "print(footbalLove or baseballHate)   # True\n",
    "print(baseballHate or footbalLove)   # True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "0df69517",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "False\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# 리나 - 축구(False) 야구(True)\n",
    "print(footbalHate and baseballLove)  # False\n",
    "print(baseballLove and footbalHate)  # False\n",
    "print(footbalHate or baseballLove)   # True\n",
    "print(baseballLove or footbalHate)   # True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "8e99e695",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# 민섭 - 축구(True) 야구(True)\n",
    "print(footbalLove and baseballLove)  # True\n",
    "print(baseballLove and footbalLove)  # True\n",
    "print(footbalLove or baseballLove)   # True\n",
    "print(baseballLove and footbalLove)  # True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "27ea4bf6",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "False\n",
      "False\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "# 경록 - 축구(False) 야구(False)\n",
    "print(footbalHate and baseballHate)  # False\n",
    "print(baseballHate and footbalHate)  # False\n",
    "print(footbalHate or baseballHate)   # False\n",
    "print(baseballHate or footbalHate)   # False"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f9edf3f7",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## 2.11 in 연산자"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "d001dd17",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "## In 연산자 출력\n",
    "print(\"h\" in \"hello\")\n",
    "print(\"h\" in \"Hello\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a3d64dc9",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## 2.12 문자열 비교"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "52e74ceb",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "## 문자열의 비교 출력\n",
    "print(\"hello\" == \"hello\")\n",
    "print(\"hello\" == \"helloo\")\n",
    "\n",
    "print('hello' != \"hello\")\n",
    "print('hello' != 'helloo')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e7a37e8a",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## 2.13 이스케이프 문자"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "ca44415d",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\"파이썬은 배우기 쉽습니다\" 라고 말했습니다\n",
      "'파이썬은 배우기 쉽습니다' 라고 말했습니다\n",
      "\"파이썬은 배우기 쉽습니다\"라고 말했습니다\n",
      "'파이썬은 배우기 쉽습니다'라고 말했습니다\n"
     ]
    }
   ],
   "source": [
    "## 이스케이프 문자 출력\n",
    "# 이스케이프 문자를 사용하지 않습니다.\n",
    "print('\"파이썬은 배우기 쉽습니다\" 라고 말했습니다')\n",
    "print(\"'파이썬은 배우기 쉽습니다' 라고 말했습니다\")\n",
    "\n",
    "# 이스케이프 문자를 사용합니다\n",
    "print(\"\\\"파이썬은 배우기 쉽습니다\\\"라고 말했습니다\")\n",
    "print('\\'파이썬은 배우기 쉽습니다\\'라고 말했습니다')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "e78ec3b5",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "파이썬은 배우기 쉽습니다\n",
      "라고 말했습니다\n",
      "파이썬은 배우기 쉽습니다\t라고 말했습니다\n",
      "파이썬은 배우기 쉽습니다\\라고 말했습니다\n"
     ]
    }
   ],
   "source": [
    "## 다양한 이스케이프 문자 출력\n",
    "print(\"파이썬은 배우기 쉽습니다\\n라고 말했습니다\")\n",
    "print(\"파이썬은 배우기 쉽습니다\\t라고 말했습니다\")\n",
    "print(\"파이썬은 배우기 쉽습니다\\\\라고 말했습니다\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a04267c2",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## 2.14 숫자 연산자"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "8890e911",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "1\n",
      "6\n",
      "2.0\n"
     ]
    }
   ],
   "source": [
    "## 사칙연산자 출력\n",
    "print(1 + 1)\n",
    "print(2 - 1)\n",
    "print(3 * 2)\n",
    "print(4 / 2)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "bc3b0e1d",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.6666666666666667\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "## 나머지 연산자 출력\n",
    "print(5 / 3)\n",
    "print(5 // 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "d6b360be",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "True\n",
      "False\n",
      "True\n",
      "False\n",
      "True\n",
      "True\n",
      "27\n",
      "7\n"
     ]
    }
   ],
   "source": [
    "## 비교/나머지/제곱 연산자 출력\n",
    "print(12 % 5)\n",
    "print(2 > 1)\n",
    "print(3 < 1)\n",
    "print(1 <= 4)\n",
    "print(1 >= 5)\n",
    "print(7 == 7)\n",
    "print(3 != 5)\n",
    "print(3 ** 3)\n",
    "print(1 * (2 + 5))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8f389a84",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## 2.15 복합 대입 연산자"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "509a8c3b",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "number :  70\n"
     ]
    }
   ],
   "source": [
    "## 복합 대입 연산자 - 숫자 출력\n",
    "num = 10\n",
    "num += 10\n",
    "num += 20\n",
    "num += 30\n",
    "print('number : ', num)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "6e255147",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "string :  안녕하세요!!\n"
     ]
    }
   ],
   "source": [
    "## 복합 대입 연산자 - 문자 출력\n",
    "str = '안녕하세요'\n",
    "str += \"!\"\n",
    "str += \"!\"\n",
    "print(\"string : \", str)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f51cca4d",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "# 3. 파이썬의 자료형"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1d32492a",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## 3.1 리스트"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "c5c012d5",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[]\n",
      "[3, 6, 9, 12, 15]\n",
      "['python', 'is', 'easy', 'to', 'learn']\n",
      "[1004, 486, 'happy', 'is', 'the', 'best']\n",
      "[7942, ['happy', 'is'], 'the', 'best']\n",
      "[1, 2, 3, 4, 5, 6, 7, 8, 9]\n"
     ]
    }
   ],
   "source": [
    "## 리스트 출력\n",
    "list_a = []\n",
    "list_b = [3, 6, 9, 12, 15]\n",
    "list_c = ['python', 'is', 'easy', 'to', 'learn']\n",
    "list_d = [1004, 486, 'happy', 'is', 'the', 'best']\n",
    "list_e = [7942, ['happy', 'is'], 'the', 'best']\n",
    "list_f = list(range(1, 10))\n",
    "\n",
    "print(list_a)\n",
    "print(list_b)\n",
    "print(list_c)\n",
    "print(list_d)\n",
    "print(list_e)\n",
    "print(list_f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "1566e4bb",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "3\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "## 리스트 - 인덱싱 출력\n",
    "a = [1, 2, 3]\n",
    "print(a[0])\n",
    "print(a[2])\n",
    "print(a[-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "3e86d3c2",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12\n",
      "[1, 2]\n",
      "['H', 'A']\n"
     ]
    }
   ],
   "source": [
    "## 리스트 - 슬라이싱 출력 1\n",
    "# 문자열 슬라이스\n",
    "a = '12345'\n",
    "print(a[0:2])\n",
    "\n",
    "# 리스트 슬라이스\n",
    "b = [1, 2, 3, 4, 5]\n",
    "print(b[0:2])\n",
    "c = ['H', 'A', 'P', 'P', 'Y']\n",
    "print(c[0:2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "4619da48",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5]\n",
      "[1, 2]\n",
      "[3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "## 리스트 - 슬라이싱 출력 2\n",
    "a = [1, 2, 3, 4, 5]\n",
    "b = a[:2]\n",
    "c = a[2:]\n",
    "\n",
    "print(a)\n",
    "print(b)\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "62992c06",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 6]\n",
      "[1, 2, 3, 1, 2, 3, 1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "## 리스트 - 연산자 출력\n",
    "a = [1, 2, 3]\n",
    "b = [4, 5, 6]\n",
    "\n",
    "print(a + b)\n",
    "print(a * 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "1e593658",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4]\n",
      "['H', 'A', 'P', 'P', 'Y']\n"
     ]
    }
   ],
   "source": [
    "## 리스트 - 요소 추가(append) 출력\n",
    "a = [1, 2, 3]\n",
    "a.append(4)\n",
    "b = ['H', 'A', 'P', 'P']\n",
    "b.append('Y')\n",
    "\n",
    "print(a)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "fc112333",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4]\n",
      "['H', 'A', 'P', 'P', 'Y']\n"
     ]
    }
   ],
   "source": [
    "## 리스트 - 요소 추가(insert)출력\n",
    "a = [1, 2, 3]\n",
    "a.insert(3, 4)\n",
    "b = ['H', 'A', 'P', 'P']\n",
    "b.insert(4, 'Y')\n",
    "\n",
    "print(a)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "b1a49fcb",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3]\n",
      "['H', 'A', 'P', 'P', 'Y']\n",
      "[1, 3]\n",
      "['H', 'A', 'P', 'P']\n"
     ]
    }
   ],
   "source": [
    "## 리스트 - 요소 제거 (del)출력\n",
    "a = [1, 2, 3]\n",
    "print(a)\n",
    "del a[1]\n",
    "\n",
    "b = ['H', 'A', 'P', 'P', 'Y']\n",
    "print(b)\n",
    "del b[-1]\n",
    "\n",
    "print(a)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "4ee12166",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3]\n",
      "['H', 'A', 'P', 'P']\n"
     ]
    }
   ],
   "source": [
    "## 리스트 - 요소 제거 (pop) 출력\n",
    "a = [1, 2, 3, 4]\n",
    "a.pop(3)\n",
    "print(a)\n",
    "\n",
    "b = ['H', 'A', 'P', 'P', 'Y']\n",
    "b.pop(-1)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "d25d477d",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "## 리스트 - 내부에 있는지 확인(in 연산자) 출력\n",
    "# 리스트 선언\n",
    "list = ['H', 'A', 'P', 'P', 'Y']\n",
    "\n",
    "print('H' in list)\n",
    "print('h' in list)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6025389c",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## 3.2 딕셔너리"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "c1bed6d4",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "# 딕셔너리 출력\n",
    "dic = {'name' : '서희원', 'phone':'010-6653-7743', 'birthday' : '0923'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "b7013146",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'name': '서희원', 'phone': '010-6653-7743', 'birthday': '0923'}\n"
     ]
    }
   ],
   "source": [
    "print(dic)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "7ea895f8",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1: 'a', 2: 'b', 3: 'c'}\n"
     ]
    }
   ],
   "source": [
    "dic_a = {1 : 'a', 2 : 'b'}\n",
    "dic_a[3] = 'c'\n",
    "print(dic_a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "5c12fa08",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1: 'a', 2: 'b', 3: 'c', 'name': 'Jihyun'}\n"
     ]
    }
   ],
   "source": [
    "dic_a['name'] = 'Jihyun'\n",
    "print(dic_a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "f0e70827",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "## 딕셔너리 - 요소 제거하기 출력\n",
    "del dic_a[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "a5b72b0e",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{2: 'b', 3: 'c', 'name': 'Jihyun'}\n"
     ]
    }
   ],
   "source": [
    "print(dic_a)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "02d40e74",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## 3.3 튜플"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "a0c30872",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'tuple' object doesn't support item deletion",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m/var/folders/78/c0mtglkd01qdvrc3g3x19nsc0000gn/T/ipykernel_41028/2040446622.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m## 튜플 - 요소값을 변경, 삭제하려는 경우 출력\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0mtuple_a\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m6\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m9\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'python'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'is'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'easy'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0;32mdel\u001b[0m \u001b[0mtuple_a\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: 'tuple' object doesn't support item deletion"
     ]
    }
   ],
   "source": [
    "## 튜플 - 요소값을 변경, 삭제하려는 경우 출력\n",
    "tuple_a = (3, 6, 9, 'python', 'is', 'easy')\n",
    "del tuple_a[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "b82d4a51",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n",
      "('is', 'easy', 'to', 'learn')\n",
      "(1004, 486, 'happy', 'is', 'the', 'best', 7942, ['happy', 'is'], 'the', 'best')\n",
      "('python', 'is', 'easy', 'to', 'learn', 'python', 'is', 'easy', 'to', 'learn')\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "## 튜플 - 인덱싱, 슬라이싱, 더하기, 곱하기, 길이 출력\n",
    "tuple_a = (3, 6, 9,  12, 15)\n",
    "tuple_b = ('python', 'is', 'easy', 'to', 'learn')\n",
    "tuple_c = (1004, 486, 'happy', 'is', 'the', 'best')\n",
    "tuple_d = (7942, ['happy', 'is'], 'the', 'best')\n",
    "print(tuple_a[1])          # indexing\n",
    "print(tuple_b[1:])         # slicing\n",
    "print(tuple_c + tuple_d)   # +\n",
    "print(tuple_b * 2)         # *\n",
    "print(len(tuple_b))        # len"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "50edf465",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "# 4. 파이썬의 제어문"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "92ff6b5a",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## 4.1 조건문"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "185634f4",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "정수 입력 : 3\n",
      "홀수입니다\n"
     ]
    }
   ],
   "source": [
    "## if 조건문 출력\n",
    "# 입력값 받기\n",
    "num = input(\"정수 입력 : \")\n",
    "num = int(num)\n",
    "\n",
    "# 짝수\n",
    "if num % 2 != 1 :\n",
    "    print(\"짝수입니다\")\n",
    "    \n",
    "# 홀수    \n",
    "if num % 2 == 1 :\n",
    "    print(\"홀수입니다\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "3345c5e4",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "정수 입력 : 4\n",
      "짝수입니다\n"
     ]
    }
   ],
   "source": [
    "## else 구문 출력\n",
    "# 입력값 \n",
    "\n",
    "# 입력값 받기\n",
    "num = input(\"정수 입력 : \")\n",
    "num = int(num)\n",
    "\n",
    "if num % 2 != 1 : # 짝수\n",
    "    print(\"짝수입니다\")\n",
    "else:             # 홀수\n",
    "    print('홀수입니다')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "bcae5cf3",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "계절을 확인할 달을 입력해 주세요 : 4\n",
      "Spring\n"
     ]
    }
   ],
   "source": [
    "## elif 구문\n",
    "# 입력값 받기\n",
    "month = int(input(\"계절을 확인할 달을 입력해 주세요 : \"))\n",
    "\n",
    "if 3 <= month <5 :\n",
    "    print('Spring')\n",
    "elif 6 <= month <= 8 :\n",
    "    print('Summer')\n",
    "elif 9 <= month <= 11 :\n",
    "    print('Autumn')\n",
    "else:\n",
    "    print('winter')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "7f08754f",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "계절을 확인할 달을 입력해 주세요 : 3\n"
     ]
    }
   ],
   "source": [
    "## pass \n",
    "\n",
    "month = int(input(\"계절을 확인할 달을 입력해 주세요 : \"))\n",
    "\n",
    "if 3 <= month <5 :\n",
    "    pass\n",
    "elif 6 <= month <= 8 :\n",
    "    pass\n",
    "elif 9 <= month <= 11 :\n",
    "    pass\n",
    "else:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "96e11081",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## 4.2 반복문"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "49db328a",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n"
     ]
    }
   ],
   "source": [
    "## for 반복문 - 리스트와 함께 사용 출력\n",
    "array = [1, 2, 3, 4, 5, 6]\n",
    "\n",
    "for var in array:\n",
    "    print(var)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "21e3831b",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "index :  0 List :  1\n",
      "index :  1 List :  2\n",
      "index :  2 List :  3\n",
      "index :  3 List :  4\n",
      "index :  4 List :  5\n",
      "index :  5 List :  6\n"
     ]
    }
   ],
   "source": [
    "## for 반복문 - 리스트와 함께 인덱스 출력\n",
    "array = [1, 2, 3, 4, 5, 6]\n",
    "\n",
    "for i,var in enumerate(array):\n",
    "    print(\"index : \", i, 'List : ', var)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "e76afa54",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "## for 반복문 - 딕셔너리와 함께 사용 출력\n",
    "dic = {\n",
    "    'name' : '정지현',\n",
    "    'phone' : '010-6653-7743',\n",
    "    'bday' : '0923'\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "6e851917",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "name 정지현\n",
      "phone 010-6653-7743\n",
      "bday 0923\n"
     ]
    }
   ],
   "source": [
    "for key in dic :\n",
    "    print(key, dic[key])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "554cd714",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 번째 반복입니다.\n",
      "2 번째 반복입니다.\n",
      "3 번째 반복입니다.\n",
      "4 번째 반복입니다.\n"
     ]
    }
   ],
   "source": [
    "### while 반복문 출력\n",
    "i = 1\n",
    "\n",
    "while i < 5:\n",
    "    print(i, '번째 반복입니다.')\n",
    "    i += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8b9d6153",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## 4.3 제어문"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "id": "159f0ac3",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 번째 반복입니다.\n",
      "> 종료하시겠습니까? (종료하실 경우 y or Y) : 2\n",
      "2 번째 반복입니다.\n",
      "> 종료하시겠습니까? (종료하실 경우 y or Y) : 565\n",
      "3 번째 반복입니다.\n",
      "> 종료하시겠습니까? (종료하실 경우 y or Y) : 6\n",
      "4 번째 반복입니다.\n",
      "> 종료하시겠습니까? (종료하실 경우 y or Y) : 6\n",
      "5 번째 반복입니다.\n",
      "> 종료하시겠습니까? (종료하실 경우 y or Y) : 5\n",
      "6 번째 반복입니다.\n",
      "> 종료하시겠습니까? (종료하실 경우 y or Y) : 6\n",
      "7 번째 반복입니다.\n",
      "> 종료하시겠습니까? (종료하실 경우 y or Y) : y\n",
      "반복을 종료합니다.\n"
     ]
    }
   ],
   "source": [
    "## break 출력\n",
    "i = 1\n",
    "\n",
    "# 무한 반복입니다\n",
    "while True :\n",
    "    # 몇 번째 반복인지 출력합니다\n",
    "    print(i, '번째 반복입니다.')\n",
    "    i += 1\n",
    "    \n",
    "# 반복을 종료합니다.\n",
    "    input_text = input(\"> 종료하시겠습니까? (종료하실 경우 y or Y) : \")\n",
    "    if input_text == ('y' or 'Y'):\n",
    "        print('반복을 종료합니다.')\n",
    "        break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "2c77faf1",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "홀수 :  1\n",
      "홀수 :  3\n",
      "홀수 :  5\n",
      "홀수 :  7\n",
      "홀수 :  9\n"
     ]
    }
   ],
   "source": [
    "## continue 출력\n",
    "# list\n",
    "array = list(range(1, 10))\n",
    "\n",
    "# 반복문을 실행\n",
    "for number in array :\n",
    "    \n",
    "    # 짝수 -> 다음 반복\n",
    "    if number % 2 == 0:\n",
    "        continue\n",
    "    # 출력 \n",
    "\n",
    "    print('홀수 : ', number)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9fc5af43",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "# 5. 파이썬의 함수"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f132368b",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## 5.1 함수"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "ab104ec5",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Python Programming\n",
      "learning about function\n"
     ]
    }
   ],
   "source": [
    "## 함수의 구조 - 매개변수 없음 출력\n",
    "# 함수를 선언합니다\n",
    "def func_print():\n",
    "    print('Python Programming')\n",
    "    print('learning about function')\n",
    "    \n",
    "# 함수 호출\n",
    "func_print()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e6a868d8",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## 5.2 매개변수"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "661090a6",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "6\n",
      "9\n",
      "12\n",
      "15\n",
      "18\n",
      "21\n",
      "24\n",
      "27\n"
     ]
    }
   ],
   "source": [
    "## 함수의 구조 - 매개변수 있음 출력\n",
    "# 함수 선언\n",
    "def multiple_table(n) :\n",
    "    array= list(range(1,10))\n",
    "    \n",
    "    for number in array:\n",
    "        print(number * n)\n",
    "        \n",
    "multiple_table(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "id": "42f9977a",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15\n",
      "55\n"
     ]
    }
   ],
   "source": [
    "## 가변 매개변수 출력\n",
    "# 가변 매개변수\n",
    "def func_sum(* num) :\n",
    "    result = 0\n",
    "    \n",
    "    for i in num :\n",
    "        result += i\n",
    "    print(result)\n",
    "    \n",
    "# 매개변수 5개\n",
    "func_sum(1, 2, 3, 4, 5)\n",
    "\n",
    "# 매개변수 10개\n",
    "func_sum(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "id": "a71a3b02",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 열심히 파이썬을 배우고 있습니다\n",
      "1 열심히 파이썬을 배우고 있습니다\n",
      "2 열심히 파이썬을 배우고 있습니다\n"
     ]
    }
   ],
   "source": [
    "## 초깃값이 설정된 매개변수 출력\n",
    "def func_print_return(string, n = 3):\n",
    "    \n",
    "    for i in range(n):\n",
    "        print(i, string)\n",
    "        \n",
    "func_print_return(\"열심히 파이썬을 배우고 있습니다\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c526ca6c",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## 5.3 반환값 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "id": "15f2b97c",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "## 리턴 출력\n",
    "# 함수 선언\n",
    "def func_print_return() :\n",
    "    result = 0\n",
    "    \n",
    "    for i in num :\n",
    "        result += i\n",
    "    # result반환\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "id": "47ccf34b",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "55\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "sum = func_sum(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)\n",
    "print(sum)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f9380cd2",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "# 7. 넘파이"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a0c09c79",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## 7.1 배열"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "id": "d9eeaf9d",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "# ndarray 생셩하기 출력\n",
    "import numpy as np\n",
    "\n",
    "# 1차원 형태 Vector\n",
    "data_1 = [1, 2, 3, 4, 5]\n",
    "\n",
    "# 2차원 형태 Matric\n",
    "data_2 = [[1, 2, 3],\n",
    "         [4, 5, 6]]\n",
    "\n",
    "data_3 = [[1, 2, 3.0],\n",
    "         [4, 5.0, 6]]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "32f00c48",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "### 예제"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "id": "361a62ef",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "mid_scores = [10, 20, 30]\n",
    "final_scores = [70, 80, 90]\n",
    "\n",
    "total = mid_scores + final_scores"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "id": "cc1dc635",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[10, 20, 30, 70, 80, 90]"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "total"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "id": "54252362",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "mid_score = np.array([10, 20, 30])\n",
    "final_score = np.array([70, 80, 90])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "id": "2df54334",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "total = mid_score + final_score"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "id": "40ac2981",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "시험 성적의 합계 :  [ 80 100 120]\n",
      "시험 성적의 평균 :  [40. 50. 60.]\n"
     ]
    }
   ],
   "source": [
    "print(\"시험 성적의 합계 : \", total)\n",
    "print(\"시험 성적의 평균 : \", total / 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "id": "60b53fed",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1) np.zeros(5) :  [0. 0. 0. 0. 0.]\n",
      "2) np.zeros((2, 5)) :  [[0. 0. 0. 0. 0.]\n",
      " [0. 0. 0. 0. 0.]]\n",
      "3) np.ones(5) :  [1. 1. 1. 1. 1.]\n",
      "4) np.empty((2, 2, 3)) :  [[[0.00000000e+000 1.00937611e-320 0.00000000e+000]\n",
      "  [0.00000000e+000 0.00000000e+000 4.47032019e-038]]\n",
      "\n",
      " [[5.24889399e-090 5.34962119e-038 4.31752662e-038]\n",
      "  [2.76998130e-057 3.99910963e+252 1.46030983e-319]]]\n",
      "5) np.arange(5) :  [0 1 2 3 4]\n",
      "6) np.full((3, 3), 7) : \n",
      " [[7 7 7]\n",
      " [7 7 7]\n",
      " [7 7 7]]\n"
     ]
    }
   ],
   "source": [
    "## ndarray - 배열 생성 함수 출력\n",
    "print(\"1) np.zeros(5) : \", np.zeros(5))\n",
    "print(\"2) np.zeros((2, 5)) : \", np.zeros((2,5)))\n",
    "print(\"3) np.ones(5) : \", np.ones(5))\n",
    "print(\"4) np.empty((2, 2, 3)) : \", np.empty((2, 2, 3)))\n",
    "print(\"5) np.arange(5) : \", np.arange(5))\n",
    "print(\"6) np.full((3, 3), 7) : \\n\", np.full((3,3),7))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bd7908ca",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## 7.2 인덱싱"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "3316a55a",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "vector_1[1] :  2\n",
      "vector_1[-1] :  5\n",
      "matrix_2[1,1] :  7\n",
      "matrix_2[2, -1] :  15\n"
     ]
    }
   ],
   "source": [
    "## 인덱싱 출력\n",
    "# 넘파이 모듈 불러오기\n",
    "import numpy as np\n",
    "\n",
    "# 1차원 형태입니다\n",
    "vector_1 = np.array([1, 2, 3, 4, 5])\n",
    "\n",
    "# 2차원 형태입니다\n",
    "matrix_2 = np.array([[1, 2, 3, 4, 5],\n",
    "                    [6, 7, 8, 9, 10],\n",
    "                    [11, 12, 13, 14, 15],\n",
    "                    [16, 17, 18, 19, 20],\n",
    "                    [21, 22, 23, 24, 25]])\n",
    "\n",
    "# 1차원 형태 - 인덱싱 입니다\n",
    "print(\"vector_1[1] : \", vector_1[1])\n",
    "print(\"vector_1[-1] : \", vector_1[-1])\n",
    "\n",
    "# 2차원 형태 - 인덱싱 입니다\n",
    "print('matrix_2[1,1] : ', matrix_2[1, 1])\n",
    "print('matrix_2[2, -1] : ', matrix_2[2, -1])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "97554270",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## 7.3 슬라이싱"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "3bb36f2c",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "scores = np.array([88, 72, 93, 94, 89, 78, 99])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "02f97c37",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([72, 93, 94])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "scores[1:4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "8ce9c5ff",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([94, 89, 78, 99])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "scores[3:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "63e24791",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([89, 78])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "scores[4:-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "776ac092",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4 5]\n",
      "[1 2 3 4]\n",
      "[2 3]\n",
      "[3 4 5]\n",
      "[3 4]\n"
     ]
    }
   ],
   "source": [
    "## 슬라이싱 - 1차원 출력\n",
    "# numpy module\n",
    "import numpy as np\n",
    "\n",
    "# 1차원 형태입니다\n",
    "vector = np.array([1, 2, 3, 4, 5])\n",
    "\n",
    "print(vector[:])\n",
    "print(vector[:4])\n",
    "print(vector[1:3])\n",
    "print(vector[2:])\n",
    "print(vector[2:-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "6fbc8669",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 4  5]\n",
      " [ 9 10]] (2, 2)\n",
      "[21 22 23 24 25] (5,)\n",
      "[21 22 23 24 25] (5,)\n",
      "[[21 22 23 24 25]] (1, 5)\n",
      "[[ 1  2]\n",
      " [ 6  7]\n",
      " [11 12]\n",
      " [16 17]\n",
      " [21 22]] (5, 2)\n",
      "[6 7] (2,)\n",
      "[[6 7]] (1, 2)\n"
     ]
    }
   ],
   "source": [
    "## 슬라이싱 - 2차원 출력\n",
    "# numpy module\n",
    "import numpy as np\n",
    "\n",
    "# 2차원 형태입니다\n",
    "matrix = np.array([[1, 2, 3, 4, 5],\n",
    "                    [6, 7, 8, 9, 10],\n",
    "                    [11, 12, 13, 14, 15],\n",
    "                    [16, 17, 18, 19, 20],\n",
    "                    [21, 22, 23, 24, 25]])\n",
    "\n",
    "print(matrix[:2, 3:], matrix[:2, 3:].shape)\n",
    "\n",
    "print(matrix[4], matrix[4].shape)\n",
    "print(matrix[4, :], matrix[4, :].shape)\n",
    "print(matrix[4:, :], matrix[4:,:].shape)\n",
    "\n",
    "print(matrix[:,:2], matrix[:,:2].shape)\n",
    "\n",
    "print(matrix[1, :2], matrix[1, :2].shape)\n",
    "print(matrix[1:2, :2], matrix[1:2, :2].shape )"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "43c1b0fd",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## 7.4 통계 및 수학 함수"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "77bb4a7a",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "합 :  45\n",
      "합 :  45\n",
      "합 :  5.0\n",
      "합 :  5.0\n",
      "표준편차 :  2.581988897471611\n",
      "분산 :  6.666666666666667\n",
      "최댓값 :  9\n",
      "최솟값 :  1\n"
     ]
    }
   ],
   "source": [
    "## 통계 및 수학 함수  출력\n",
    "# 2차원 형태입니다\n",
    "matrix = np.array([[1, 2, 3],\n",
    "                    [4, 5, 6],\n",
    "                    [7, 8, 9]])\n",
    "\n",
    "print(\"합 : \", np.sum(matrix))     # sum - np\n",
    "print(\"합 : \", matrix.sum())       # sum\n",
    "print(\"합 : \", np.mean(matrix))    # mean - np\n",
    "print(\"합 : \", matrix.mean())      # mean\n",
    "print(\"표준편차 : \", np.std(matrix)) # 표준편차\n",
    "print(\"분산 : \", np.var(matrix))    # 분산\n",
    "print(\"최댓값 : \", np.max(matrix))   # 최댓값\n",
    "print(\"최솟값 : \", np.min(matrix))   # 최솟값"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "f8a0c65e",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "열에서 최댓값 :  [7 8 9]\n",
      "열에서 최솟값 :  [1 2 3]\n",
      "열에서 평균값 :  [4. 5. 6.]\n",
      "행에서 최댓값 :  [3 6 9]\n",
      "행에서 최솟값 :  [1 4 7]\n",
      "행에서 평균값 :  [2. 5. 8.]\n"
     ]
    }
   ],
   "source": [
    "# 열과 행에서 최댓값 최솟값을 찾는 경우\n",
    "# 열에서 찾습니다\n",
    "print(\"열에서 최댓값 : \", np.max(matrix, axis=0))\n",
    "print(\"열에서 최솟값 : \", np.min(matrix, axis=0))\n",
    "print(\"열에서 평균값 : \", np.mean(matrix, axis=0))\n",
    "\n",
    "# 행에서 찾습니다\n",
    "print(\"행에서 최댓값 : \", np.max(matrix, axis=1))\n",
    "print(\"행에서 최솟값 : \", np.min(matrix, axis=1))\n",
    "print(\"행에서 평균값 : \", np.mean(matrix, axis=1))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3c309d12",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## 7.5 난수 생성"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "b4fe8e84",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0과 1.0 사이에서 10개의 실수 나눗 생성 :  [0.5488135  0.71518937 0.60276338 0.54488318 0.4236548  0.64589411\n",
      " 0.43758721 0.891773   0.96366276 0.38344152]\n",
      "1부터 45 사이에 6개 정수를 생성합니다. :  [38 39 23 24 17 37]\n",
      "평균이 0.0이고 표준편차가 1.0인 정규분포에서 5개의 수를 뽑음 :  [ -5.17848105  10.70317597 -14.05964029  15.81107748  -0.85475023]\n",
      "1.0보다 크고 5.0 보다 작은 5개의 수를 뽑습니다. :  [4.20364301 3.08190992 3.71551812 3.88253062 3.32807917]\n",
      "0.0~1.0 사이의 3개 실수를 랜덤으로 생성합니다.(random_sample) : \n",
      "  [[0.53737323 0.75861562 0.10590761]\n",
      " [0.47360042 0.18633234 0.73691818]\n",
      " [0.21655035 0.13521817 0.32414101]]\n"
     ]
    }
   ],
   "source": [
    "## 난수 생성 함수를 출력\n",
    "# 난수를 생성합니다\n",
    "# 초깃값을 설정합니다\n",
    "import numpy as np\n",
    "np.random.seed(0)\n",
    "\n",
    "print(\"0과 1.0 사이에서 10개의 실수 나눗 생성 : \", np.random.random(10))\n",
    "print(\"1부터 45 사이에 6개 정수를 생성합니다. : \", np.random.randint(0, 46, 6))\n",
    "print(\"평균이 0.0이고 표준편차가 1.0인 정규분포에서 5개의 수를 뽑음 : \", np.random.normal(0.0, 11.0, 5))\n",
    "print(\"1.0보다 크고 5.0 보다 작은 5개의 수를 뽑습니다. : \", np.random.uniform(1.0, 5.0, 5))\n",
    "\n",
    "\n",
    "print(\"0.0~1.0 사이의 3개 실수를 랜덤으로 생성합니다.(random_sample) : \\n \", np.random.random_sample((3,3)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a8510c60",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## 7.6 정렬"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "42ec64a7",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1차원 배열 sort()정렬 전 :  [ 1.62434536 -0.61175641 -0.52817175 -1.07296862  0.86540763]\n",
      "1차원 배열 sort()정렬 후 :  [-1.07296862 -0.61175641 -0.52817175  0.86540763  1.62434536]\n",
      "2차원 배열 sort()정렬 전 : \n",
      " [[-2.3015387   1.74481176 -0.7612069   0.3190391  -0.24937038]\n",
      " [ 1.46210794 -2.06014071 -0.3224172  -0.38405435  1.13376944]\n",
      " [-1.09989127 -0.17242821 -0.87785842  0.04221375  0.58281521]\n",
      " [-1.10061918  1.14472371  0.90159072  0.50249434  0.90085595]\n",
      " [-0.68372786 -0.12289023 -0.93576943 -0.26788808  0.53035547]]\n",
      "2차원 배열 sort()정렬 후 : \n",
      " [[-2.3015387  -0.7612069  -0.24937038  0.3190391   1.74481176]\n",
      " [-2.06014071 -0.38405435 -0.3224172   1.13376944  1.46210794]\n",
      " [-1.09989127 -0.87785842 -0.17242821  0.04221375  0.58281521]\n",
      " [-1.10061918  0.50249434  0.90085595  0.90159072  1.14472371]\n",
      " [-0.93576943 -0.68372786 -0.26788808 -0.12289023  0.53035547]]\n",
      "2차원 배열 axis=0축 기준 정렬 전 : \n",
      " :  [[-0.69166075 -0.39675353 -0.6871727  -0.84520564 -0.67124613]\n",
      " [-0.0126646  -1.11731035  0.2344157   1.65980218  0.74204416]\n",
      " [-0.19183555 -0.88762896 -0.74715829  1.6924546   0.05080775]\n",
      " [-0.63699565  0.19091548  2.10025514  0.12015895  0.61720311]\n",
      " [ 0.30017032 -0.35224985 -1.1425182  -0.34934272 -0.20889423]]\n",
      "2차원 배열 axis=0축 기준 정렬 후 : \n",
      " :  [[-0.69166075 -1.11731035 -1.1425182  -0.84520564 -0.67124613]\n",
      " [-0.63699565 -0.88762896 -0.74715829 -0.34934272 -0.20889423]\n",
      " [-0.19183555 -0.39675353 -0.6871727   0.12015895  0.05080775]\n",
      " [-0.0126646  -0.35224985  0.2344157   1.65980218  0.61720311]\n",
      " [ 0.30017032  0.19091548  2.10025514  1.6924546   0.74204416]]\n",
      "2차원 배열 axis=1축 기준 정렬 전 : \n",
      " :  [[ 0.58662319  0.83898341  0.93110208  0.28558733  0.88514116]\n",
      " [-0.75439794  1.25286816  0.51292982 -0.29809284  0.48851815]\n",
      " [-0.07557171  1.13162939  1.51981682  2.18557541 -1.39649634]\n",
      " [-1.44411381 -0.50446586  0.16003707  0.87616892  0.31563495]\n",
      " [-2.02220122 -0.30620401  0.82797464  0.23009474  0.76201118]]\n",
      "2차원 배열 axis=1축 기준 정렬 후 : \n",
      " :  [[-2.02220122 -0.50446586  0.16003707 -0.29809284 -1.39649634]\n",
      " [-1.44411381 -0.30620401  0.51292982  0.23009474  0.31563495]\n",
      " [-0.75439794  0.83898341  0.82797464  0.28558733  0.48851815]\n",
      " [-0.07557171  1.13162939  0.93110208  0.87616892  0.76201118]\n",
      " [ 0.58662319  1.25286816  1.51981682  2.18557541  0.88514116]]\n",
      "2차원 배열 첫 번째 행만 정렬 전 : \n",
      " :  [[-0.22232814 -0.20075807  0.18656139  0.41005165  0.19829972]\n",
      " [ 0.11900865 -0.67066229  0.37756379  0.12182127  1.12948391]\n",
      " [ 1.19891788  0.18515642 -0.37528495 -0.63873041  0.42349435]\n",
      " [ 0.07734007 -0.34385368  0.04359686 -0.62000084  0.69803203]\n",
      " [-0.44712856  1.2245077   0.40349164  0.59357852 -1.09491185]]\n",
      "2차원 배열 첫 번째 행만 정렬 후 : \n",
      " :  [[-0.44712856 -0.20075807  0.18656139  0.41005165  0.19829972]\n",
      " [-0.22232814 -0.67066229  0.37756379  0.12182127  1.12948391]\n",
      " [ 0.07734007  0.18515642 -0.37528495 -0.63873041  0.42349435]\n",
      " [ 0.11900865 -0.34385368  0.04359686 -0.62000084  0.69803203]\n",
      " [ 1.19891788  1.2245077   0.40349164  0.59357852 -1.09491185]]\n"
     ]
    }
   ],
   "source": [
    "## 정렬 - sort()출력\n",
    "# 난수를 생성기의 시드값에 따라 정해진 난수를 생성합니다\n",
    "np.random.seed(1)\n",
    "\n",
    "# 표준편차가 1, 평균값이 0인 정규분포에서 랜덤으로 숫자를 결정합니다\n",
    "# 1차원 입니다\n",
    "vector = np.random.randn(5)\n",
    "\n",
    "print(\"1차원 배열 sort()정렬 전 : \", vector)\n",
    "vector.sort()\n",
    "print(\"1차원 배열 sort()정렬 후 : \", vector)\n",
    "\n",
    "# 2차원 입니다\n",
    "matrix_1 = np.random.randn(5,5)\n",
    "print(\"2차원 배열 sort()정렬 전 : \\n\", matrix_1)\n",
    "matrix_1.sort()\n",
    "print(\"2차원 배열 sort()정렬 후 : \\n\", matrix_1)\n",
    "\n",
    "# 특정 축을 기준으로 정렬합니다\n",
    "matrix_2 = np.random.randn(5, 5)\n",
    "print(\"2차원 배열 axis=0축 기준 정렬 전 : \\n : \", matrix_2 )\n",
    "matrix_2.sort(axis=0)\n",
    "print(\"2차원 배열 axis=0축 기준 정렬 후 : \\n : \", matrix_2 )\n",
    "\n",
    "matrix_3 = np.random.randn(5, 5)\n",
    "print(\"2차원 배열 axis=1축 기준 정렬 전 : \\n : \", matrix_3 )\n",
    "matrix_3.sort(axis=0)\n",
    "print(\"2차원 배열 axis=1축 기준 정렬 후 : \\n : \", matrix_3 )\n",
    "\n",
    "# 첫 번째 행만 정렬합니다\n",
    "matrix_4 = np.random.randn(5, 5)\n",
    "print('2차원 배열 첫 번째 행만 정렬 전 : \\n : ', matrix_4)\n",
    "matrix_4[:, 0].sort()\n",
    "print('2차원 배열 첫 번째 행만 정렬 후 : \\n : ', matrix_4)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "9b12cb6b",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "랜덤으로 생성합니다. 된 2차원 배열 : \n",
      " [[-1.31778998  0.35714308  0.45707967  1.875644   -1.73899644]\n",
      " [ 1.23880498 -1.25338479 -0.58707263  0.02825459  1.71586241]\n",
      " [-2.2911804   0.27501037 -0.95155817  1.16239809  0.08127246]\n",
      " [-1.46256928  1.1787978  -0.5468846   1.48143431  0.26810084]\n",
      " [ 0.8328146   0.9282658   0.56408109 -0.91425236 -0.83099886]]\n",
      "matrix배열의 첫 번째 열에 vector배열의 요소값 대입 : \n",
      "  [[ 5.          3.          1.          2.          4.        ]\n",
      " [ 1.23880498 -1.25338479 -0.58707263  0.02825459  1.71586241]\n",
      " [-2.2911804   0.27501037 -0.95155817  1.16239809  0.08127246]\n",
      " [-1.46256928  1.1787978  -0.5468846   1.48143431  0.26810084]\n",
      " [ 0.8328146   0.9282658   0.56408109 -0.91425236 -0.83099886]]\n",
      "argsort()로 정렬된 배열 : \n",
      " [[ 1.          2.          3.          4.          5.        ]\n",
      " [-0.58707263  0.02825459 -1.25338479  1.71586241  1.23880498]\n",
      " [-0.95155817  1.16239809  0.27501037  0.08127246 -2.2911804 ]\n",
      " [-0.5468846   1.48143431  1.1787978   0.26810084 -1.46256928]\n",
      " [ 0.56408109 -0.91425236  0.9282658  -0.83099886  0.8328146 ]]\n"
     ]
    }
   ],
   "source": [
    "## 정렬 - argsort() 출력\n",
    "\n",
    "# 2차원 배열을 생성합니다\n",
    "import numpy as np\n",
    "matrix = np.random.randn(5, 5)\n",
    "print(\"랜덤으로 생성합니다. 된 2차원 배열 : \\n\", matrix)\n",
    "\n",
    "# 기준이 되는 1차원 배열을 생성합니다\n",
    "vector = np.array([5, 3, 1, 2, 4])\n",
    "\n",
    "# matrix 배열이 첫 번째 열에 vector 배열의 요소값을 넣어줍니다\n",
    "matrix[0] = vector\n",
    "print(\"matrix배열의 첫 번째 열에 vector배열의 요소값 대입 : \\n \", matrix)\n",
    "print(\"argsort()로 정렬된 배열 : \\n\", matrix[:, matrix[0].argsort()])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d47e7003",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## 7.7 배열의 크기 바꾸기"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "71ab68ef",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "matrix.shape :  (5, 4)\n",
      "matrix.reshape(2, 10) : \n",
      " [[ 1  2  3  4  5  6  7  8  9 10]\n",
      " [11 12 13 14 15 16 17 18 19 20]]\n",
      "matrix.size :  20\n",
      "reshape(1, -1) : \n",
      " [[ 1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20]]\n",
      "reshape(2, -1) : \n",
      " [[ 1  2  3  4  5  6  7  8  9 10]\n",
      " [11 12 13 14 15 16 17 18 19 20]]\n",
      "reshape(4, -1) : \n",
      " [[ 1  2  3  4  5]\n",
      " [ 6  7  8  9 10]\n",
      " [11 12 13 14 15]\n",
      " [16 17 18 19 20]]\n",
      "reshape(5, -1) : \n",
      " [[ 1  2  3  4]\n",
      " [ 5  6  7  8]\n",
      " [ 9 10 11 12]\n",
      " [13 14 15 16]\n",
      " [17 18 19 20]]\n",
      "reshape(-1) : \n",
      " [ 1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20]\n"
     ]
    }
   ],
   "source": [
    "## 배열의 크기 바꾸기 reshape()출력\n",
    "# (5, 4)\n",
    "data = [[1, 2, 3 ,4],\n",
    "        [5, 6, 7, 8],\n",
    "        [9, 10, 11, 12],\n",
    "        [13, 14, 15, 16],\n",
    "        [17, 18, 19, 20]]\n",
    "\n",
    "matrix = np.array(data)\n",
    "print(\"matrix.shape : \", matrix.shape)\n",
    "\n",
    "print(\"matrix.reshape(2, 10) : \\n\", matrix.reshape(2, 10))\n",
    "\n",
    "# 주의사항 : 배열의 크기를 변경할 때 행과 열의 개수는 동일해야 합니다\n",
    "# 따라서 함수를 사용해서 크기를 먼저 사용합니다\n",
    "print(\"matrix.size : \", matrix.size)\n",
    "\n",
    "# reshape 자주 사용되는 -1 매개변수는 해당하는 열의 개수의 맞게 변경해줍니다\n",
    "print(\"reshape(1, -1) : \\n\", matrix.reshape(1, -1))\n",
    "print(\"reshape(2, -1) : \\n\", matrix.reshape(2, -1))\n",
    "print(\"reshape(4, -1) : \\n\", matrix.reshape(4, -1))\n",
    "print(\"reshape(5, -1) : \\n\", matrix.reshape(5, -1))\n",
    "\n",
    "# 1차원 배열로 변경해줍니다\n",
    "print(\"reshape(-1) : \\n\", matrix.reshape(-1))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5a5ec74a",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## 7.8 벡터나 행렬 전치하기"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "42ea870c",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "matrix : \n",
      " [[ 1  2  3  4]\n",
      " [ 5  6  7  8]\n",
      " [ 9 10 11 12]\n",
      " [13 14 15 16]\n",
      " [17 18 19 20]]\n",
      "matrix.T : \n",
      " [[ 1  5  9 13 17]\n",
      " [ 2  6 10 14 18]\n",
      " [ 3  7 11 15 19]\n",
      " [ 4  8 12 16 20]]\n",
      "matrix.transpose() : \n",
      " [[ 1  5  9 13 17]\n",
      " [ 2  6 10 14 18]\n",
      " [ 3  7 11 15 19]\n",
      " [ 4  8 12 16 20]]\n",
      "np.transpose(matrix) : \n",
      " [[ 1  5  9 13 17]\n",
      " [ 2  6 10 14 18]\n",
      " [ 3  7 11 15 19]\n",
      " [ 4  8 12 16 20]]\n",
      "matrix.swapaxes(0,1) : \n",
      " [[ 1  5  9 13 17]\n",
      " [ 2  6 10 14 18]\n",
      " [ 3  7 11 15 19]\n",
      " [ 4  8 12 16 20]]\n",
      "matrix 데이터는 복사되지 않았습니다. : \n",
      " [[ 1  2  3  4]\n",
      " [ 5  6  7  8]\n",
      " [ 9 10 11 12]\n",
      " [13 14 15 16]\n",
      " [17 18 19 20]]\n"
     ]
    }
   ],
   "source": [
    "# 벡터나 행렬 전치 (transpose, swapaxes)출력\n",
    "data = [[1, 2, 3 ,4],\n",
    "        [5, 6, 7, 8],\n",
    "        [9, 10, 11, 12],\n",
    "        [13, 14, 15, 16],\n",
    "        [17, 18, 19, 20]]\n",
    "import numpy as np\n",
    "matrix = np.array(data)\n",
    "\n",
    "print('matrix : \\n', matrix)\n",
    "print(\"matrix.T : \\n\", matrix.T)\n",
    "print(\"matrix.transpose() : \\n\", matrix.transpose())\n",
    "print(\"np.transpose(matrix) : \\n\", np.transpose(matrix))\n",
    "print(\"matrix.swapaxes(0,1) : \\n\", matrix.swapaxes(0, 1))\n",
    "print(\"matrix 데이터는 복사되지 않았습니다. : \\n\", matrix)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "972db930",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## 7.9 행렬 펼치기"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "3f36a4f0",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(5, 4)\n",
      "[ 1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20]\n",
      "[[ 1  2  3  4]\n",
      " [ 5  6  7  8]\n",
      " [ 9 10 11 12]\n",
      " [13 14 15 16]\n",
      " [17 18 19 20]]\n",
      "1\n",
      "[ 1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20]\n"
     ]
    }
   ],
   "source": [
    "## flatten(행렬 펼치기) 출력 \n",
    "# (5, 4 구조)\n",
    "data = [[1, 2, 3 ,4],\n",
    "        [5, 6, 7, 8],\n",
    "        [9, 10, 11, 12],\n",
    "        [13, 14, 15, 16],\n",
    "        [17, 18, 19, 20]]\n",
    "\n",
    "matrix = np.array(data)\n",
    "\n",
    "print(matrix.shape)\n",
    "print(matrix.flatten())\n",
    "\n",
    "# flatten()함수를 사용해도 matrix 2차원 배열 자체는 변화가 없습니다.\n",
    "print(matrix)\n",
    "\n",
    "# flatten()함수를 사용하면 1차원 배열로 변경됩니다\n",
    "vec_flatten = matrix.flatten()\n",
    "print(vec_flatten.ndim)\n",
    "print(vec_flatten)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9a99e67b",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## 7.10 산술 연산 및 선형대수"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "047ab15a",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 3  4  5]\n",
      " [ 6  7  8]\n",
      " [ 9 10 11]]\n",
      "[[-1  0  1]\n",
      " [ 2  3  4]\n",
      " [ 5  6  7]]\n",
      "[[0.5 1.  1.5]\n",
      " [2.  2.5 3. ]\n",
      " [3.5 4.  4.5]]\n",
      "[[ 2  4  6]\n",
      " [ 8 10 12]\n",
      " [14 16 18]]\n",
      "[[ 3  6  9]\n",
      " [12 15 18]\n",
      " [21 24 27]]\n",
      "[[-1 -2 -3]\n",
      " [-4 -5 -6]\n",
      " [-7 -8 -9]]\n",
      "[[0.5 0.5 0.5]\n",
      " [0.5 0.5 0.5]\n",
      " [0.5 0.5 0.5]]\n",
      "[[  2   8  18]\n",
      " [ 32  50  72]\n",
      " [ 98 128 162]]\n"
     ]
    }
   ],
   "source": [
    "## 산술 연산 및 선형대수 1 출력\n",
    "# (3, 3)\n",
    "matrix_1 = np.array([[1, 2, 3],\n",
    "                    [4, 5, 6],\n",
    "                    [7, 8, 9]])\n",
    "\n",
    "matrix_2 = np.array([[2, 4, 6],\n",
    "                    [8, 10, 12],\n",
    "                    [14, 16, 18]])\n",
    "\n",
    "# 2차원 배열에 사칙 연산을 계산합니다\n",
    "print(matrix_1 + 2)\n",
    "print(matrix_1 - 2)\n",
    "print(matrix_1 / 2)\n",
    "print(matrix_1 * 2)\n",
    "\n",
    "# 2차원 배열끼리 사칙연산을 계산합니다\n",
    "print(matrix_1 + matrix_2)\n",
    "print(matrix_1 - matrix_2)\n",
    "print(matrix_1 / matrix_2)\n",
    "print(matrix_1 * matrix_2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "982e3030",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[11 12 13]\n",
      " [14 15 16]\n",
      " [17 18 19]]\n",
      "[[11 12 13]\n",
      " [14 15 16]\n",
      " [17 18 19]]\n",
      "[[-1 -2 -3]\n",
      " [-4 -5 -6]\n",
      " [-7 -8 -9]]\n",
      "[[-1 -2 -3]\n",
      " [-4 -5 -6]\n",
      " [-7 -8 -9]]\n",
      "[[ 60  72  84]\n",
      " [132 162 192]\n",
      " [204 252 300]]\n",
      "[[ 60  72  84]\n",
      " [132 162 192]\n",
      " [204 252 300]]\n"
     ]
    }
   ],
   "source": [
    "## 산술 연산 및 선형대수 2 출력\n",
    "# (3, 3)\n",
    "matrix_1 = np.array([[1, 2, 3],\n",
    "                    [4, 5, 6],\n",
    "                    [7, 8, 9]])\n",
    "\n",
    "matrix_2 = np.array([[2, 4, 6],\n",
    "                    [8, 10, 12],\n",
    "                    [14, 16, 18]])\n",
    "\n",
    "# (3, 0)이 벡터를 더하는 경우입니다\n",
    "print(matrix_1 + [10, 10, 10])\n",
    "\n",
    "# (3, 1)이 벡터를 더하는 경우입니다.\n",
    "print(matrix_1 + [[10], [10], [10]])\n",
    "\n",
    "# 행렬의 덧셈과 뻴셈입니다\n",
    "# add와 subtract 함수를 사용합니다\n",
    "print(np.subtract(matrix_1, matrix_2))\n",
    "print(np.subtract(matrix_1, matrix_2))\n",
    "\n",
    "# 행렬의 곱셉입니다\n",
    "# dot 함수를 사용합니다\n",
    "print(np.dot(matrix_1, matrix_2))\n",
    "\n",
    "# @연산자 사용은 파이썬 3.5이상 버전 가능합니다\n",
    "print(matrix_1 @ matrix_2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dedd75fc",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## 7.11 불리언"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "6aff70f0",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[False False False]\n",
      " [False False False]\n",
      " [False False False]]\n",
      "[[False False False]\n",
      " [False False False]\n",
      " [False False False]]\n",
      "[[False False False]\n",
      " [False False False]\n",
      " [False False False]]\n",
      "[[ True  True  True]\n",
      " [ True  True  True]\n",
      " [ True  True  True]]\n",
      "[[ True  True  True]\n",
      " [ True  True  True]\n",
      " [ True  True  True]]\n",
      "[[ True  True  True]\n",
      " [ True  True  True]\n",
      " [ True  True  True]]\n",
      "[]\n",
      "[]\n",
      "[]\n",
      "[1 2 3 4 5 6 7 8 9]\n",
      "[1 2 3 4 5 6 7 8 9]\n",
      "[1 2 3 4 5 6 7 8 9]\n"
     ]
    }
   ],
   "source": [
    "## 배열 간의 비교 연산 출력\n",
    "# (3, 3)\n",
    "matrix_1 = np.array([[1, 2, 3],\n",
    "                    [4, 5, 6],\n",
    "                    [7, 8, 9]])\n",
    "\n",
    "matrix_2 = np.array([[2, 4, 6],\n",
    "                    [8, 10, 12],\n",
    "                    [14, 16, 18]])\n",
    "\n",
    "# 배열 간의 비교 연산입니다\n",
    "print(matrix_1 > matrix_2)\n",
    "print(matrix_1 >= matrix_2)\n",
    "print(matrix_1 == matrix_2)\n",
    "print(matrix_1 != matrix_2)\n",
    "print(matrix_1 < matrix_2)\n",
    "print(matrix_1 <= matrix_2)\n",
    "\n",
    "# 반환한 불리언 배열을 인덱스로 하여 해당 요소값을 확인합니다\n",
    "print(matrix_1[matrix_1 > matrix_2])\n",
    "print(matrix_1[matrix_1 >= matrix_2])\n",
    "print(matrix_1[matrix_1 == matrix_2])\n",
    "print(matrix_1[matrix_1 != matrix_2])\n",
    "print(matrix_1[matrix_1 < matrix_2])\n",
    "print(matrix_1[matrix_1 <= matrix_2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "dc295f3c",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[False  True  True  True False False False False False  True]\n",
      "['도윤' '준우' '지호' '봉기']\n"
     ]
    }
   ],
   "source": [
    "## 불리언 값으로 인덱싱\n",
    "# (10, )\n",
    "# 1차원 배열 만들기\n",
    "vector_1 = np.array([70, 71.3, 72.1, 73, 68, 59, 55, 66, 60, 80])\n",
    "vector_2 = np.array([\"하준\", '도윤', '준우', '지호', '제균', '시우', '주원', '민준', '지현', '봉기'])\n",
    "\n",
    "# True, False return\n",
    "result_bool = vector_1 > 70\n",
    "print(result_bool)\n",
    "\n",
    "# return T,F index to find data\n",
    "print(vector_2[result_bool])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "70a288b7",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## 예제"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "3bb593c9",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "대상자들의 키 :  [1.83 1.76 1.69 1.86 1.77 1.73]\n",
      "대상자들의 몸무게 :  [86 74 59 95 80 68]\n",
      "대상자들의 BMI\n",
      "[25.68007405 23.88946281 20.65754    27.45982194 25.53544639 22.72043837]\n"
     ]
    }
   ],
   "source": [
    "heights = [1.83, 1.76, 1.69, 1.86, 1.77, 1.73]\n",
    "weights = [86, 74,  59, 95, 80, 68]\n",
    "\n",
    "np.heights = np.array(heights)\n",
    "np.weights = np.array(weights)\n",
    "\n",
    "bmi = np.weights/(np.heights ** 2)\n",
    "print(\"대상자들의 키 : \", np.heights)\n",
    "print(\"대상자들의 몸무게 : \", np.weights)\n",
    "print(\"대상자들의 BMI\")\n",
    "print(bmi)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "97e9c3d7",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.6"
  },
  "vscode": {
   "interpreter": {
    "hash": "31f2aee4e71d21fbe5cf8b01ff0e069b9275f58929596ceb00d14d90e3e16cd6"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}