Practice1-3_Basic_InputNumpy_KK.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 파이썬 데이터분석 특화 데이터 형태: Numpy\n",
    "\n",
    "- **목적:** 고성능 과학계산을 위한 데이터분석 패키지로 다차원의 데이터를 활용하게 함  \n",
    "(https://numpy.org/doc/stable/index.html)\n",
    "> - 저차원 및 고차원 데이터 입출력 및 산술연산\n",
    "> - 대표적으로 사용되는 표준 수학 함수기능 지원\n",
    "> - 행렬(저차원 및 고차원)을 다루는 선형대수 및 변환기능 지원\n",
    "\n",
    "- **Numpy:** Numerical Python의 약자로 수치를 다루는 분야를 위한 패키지\n",
    "> - Array 또는 Matrix와 같은 자료구조 수치를 다루는 Python 데이터형태\n",
    ">> - array: 같은 종류(자료형)의 데이터를 저장하는 함수\n",
    ">> - ndarray: array함수로 만든 다차원의 데이터 형태(모든 값은 같은 자료형)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 배열(Array) 생성\n",
    "\n",
    "```python\n",
    "np.array() # 리스트와 같은 순서가 있는 데이터를 받아 Numpy 데이터 생성\n",
    "```\n",
    "\n",
    "| 함수 | 내용 |\n",
    "|------------|-----------------------------------------------------------------------------------------------------|\n",
    "| np.array | 입력된 데이터를 ndarray로 변환. dtype을 명시하면 자료형을 설정할 수 있다 |\n",
    "| np.asarray | 입력 데이터를 ndarray로 변환하나 이미 ndarray일 경우에는 새로 메모리에 ndarray가 생성되지는 않는다 |\n",
    "| np.arange | range 함수와 유사하나 ndarray를 반환 |\n",
    "| np.ones | 전달인자로 전달한 dtype과 모양(행,렬)으로 배열을 생성하고 모든 내용을 1로 초기화하여 ndarray를 반환 |\n",
    "| np.zeros | ones와 같으나 초기값이 0이다 |\n",
    "| np.empty | ones와 zeros와 비슷하나 값을 초기화하지는 않는다 |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-15T03:57:29.001325Z",
     "start_time": "2021-03-15T03:57:28.848729Z"
    }
   },
   "outputs": [],
   "source": [
    "# Functions for generating scalar, vector, and multi-dimensional data\n",
    "import numpy as np\n",
    "\n",
    "a1d = np.array([1,2,3])\n",
    "print(a1d)\n",
    "print(type(a1d))\n",
    "print(a1d.dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-15T03:57:29.032237Z",
     "start_time": "2021-03-15T03:57:29.006308Z"
    }
   },
   "outputs": [],
   "source": [
    "b2d = np.array([[1,2,3], [4,5,6]]) # 각 배열의 길이는 동일해야 함\n",
    "print(b2d)\n",
    "print(type(b2d))\n",
    "print(b2d.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-15T03:57:29.048197Z",
     "start_time": "2021-03-15T03:57:29.034232Z"
    }
   },
   "outputs": [],
   "source": [
    "c3d = np.array([[[1,2,3], [4,5,6]]])\n",
    "print(c3d)\n",
    "print(type(c3d))\n",
    "print(c3d.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-15T03:57:29.081109Z",
     "start_time": "2021-03-15T03:57:29.055180Z"
    }
   },
   "outputs": [],
   "source": [
    "c3d = np.array([[[1,2,3], [4,5,6]],\n",
    "                [[10,20,30], [40,50,60]]])\n",
    "print(c3d)\n",
    "print(type(c3d))\n",
    "print(c3d.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-15T03:57:29.095078Z",
     "start_time": "2021-03-15T03:57:29.085098Z"
    }
   },
   "outputs": [],
   "source": [
    "# 타입변환\n",
    "test = [10,20,30]\n",
    "print(type(test))\n",
    "test2 = np.asarray(test)\n",
    "print(type(test2))\n",
    "print(test, test2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-15T03:57:29.110029Z",
     "start_time": "2021-03-15T03:57:29.101056Z"
    }
   },
   "outputs": [],
   "source": [
    "# array sequence generating\n",
    "np.arange(1,20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-15T03:57:29.124995Z",
     "start_time": "2021-03-15T03:57:29.114021Z"
    }
   },
   "outputs": [],
   "source": [
    "# Functions for generating data\n",
    "a2d = np.zeros((3,3))\n",
    "print(a2d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-15T03:57:29.154914Z",
     "start_time": "2021-03-15T03:57:29.132973Z"
    }
   },
   "outputs": [],
   "source": [
    "b2d = np.ones((2,3))\n",
    "print(b2d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-15T03:57:29.170866Z",
     "start_time": "2021-03-15T03:57:29.157906Z"
    }
   },
   "outputs": [],
   "source": [
    "c2d = np.full((3,3), 7)\n",
    "print(c2d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-15T03:57:29.185831Z",
     "start_time": "2021-03-15T03:57:29.171863Z"
    }
   },
   "outputs": [],
   "source": [
    "d2d = np.eye(3)\n",
    "print(d2d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-15T03:57:29.201788Z",
     "start_time": "2021-03-15T03:57:29.188821Z"
    }
   },
   "outputs": [],
   "source": [
    "e2d = np.random.random((2,2))\n",
    "print(e2d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-15T03:57:29.215746Z",
     "start_time": "2021-03-15T03:57:29.204777Z"
    }
   },
   "outputs": [],
   "source": [
    "# 값의 type 변환\n",
    "print(np.array(np.random.random((2,2)), dtype=np.float64))\n",
    "print(np.array(np.random.random((2,2)), dtype=np.complex))\n",
    "print(np.array(np.random.random((2,2)), dtype=np.int))\n",
    "print(np.array(np.random.random((2,2)), dtype=np.bool))\n",
    "print(np.array(np.random.random((2,2)), dtype=np.object))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 배열 연산\n",
    "\n",
    "- 기본 수학 함수는 배열에서 값마다 계산되며 numpy 내장 함수 모두 사용 가능\n",
    "- 값연산 이외에 벡터와 다차원 연산이 가능하기 때문에 반복문(for, while) 사용없이 직관적 연산 가능\n",
    "- (고급) 크기가 다른 배열간의 연산도 브로드캐스팅(Broadcasting) 방식으로 연산 가능\n",
    "\n",
    "**1) 단일 배열에 사용하는 함수**\n",
    "\n",
    "| 함수 | 설명 |\n",
    "|------------------------|--------------------------------------------------------------------------|\n",
    "| abs, fabs | 각 원소의 절대값을 구한다. 복소수가 아닌 경우에는 fabs로 빠르게 연산가능 |\n",
    "| sqrt | 제곱근을 계산 arr ** 0.5와 동일 |\n",
    "| square | 제곱을 계산 arr ** 2와 동일 |\n",
    "| Exp | 각 원소에 지수 ex를 계산 |\n",
    "| Log, log10, log2, logp | 각각 자연로그, 로그10, 로그2, 로그(1+x) |\n",
    "| sign | 각 원소의 부호를 계산 |\n",
    "| ceil | 각 원소의 소수자리 올림 |\n",
    "| floor | 각 원소의 소수자리 버림 |\n",
    "| rint | 각 원소의 소수자리 반올림. dtype 유지 |\n",
    "| modf | 원소의 몫과 나머지를 각각 배열로 반환 |\n",
    "| isnan | 각 원소가 숫자인지 아닌지 NaN으로 나타내는 불리언 배열 |\n",
    "| isfinite, isinf | 배열의 각 원소가 유한한지 무한한지 나타내는 불리언 배열 |\n",
    "| cos, cosh, sin, sinh, tan, tanh | 일반 삼각함수와 쌍곡삼각 함수 |\n",
    "| logical_not | 각 원소의 논리 부정(not) 값 계산 |\n",
    "\n",
    "**2) 서로 다른 배열에 사용하는 함수**\n",
    "\n",
    "| 함수 | 설명 |\n",
    "|------------------------------------------------------------|----------------------------------------------------------------------|\n",
    "| add | 두 배열에서 같은 위치의 원소끼리 덧셈 |\n",
    "| subtract | 첫번째 배열 원소 - 두번째 배열 원소 |\n",
    "| multiply | 배열의 원소끼리 곱셈 |\n",
    "| divide | 첫번째 배열의 원소에서 두번째 배열의 원소를 나눗셈 |\n",
    "| power | 첫번째 배열의 원소에 두번째 배열의 원소만큼 제곱 |\n",
    "| maximum, fmax | 두 원소 중 큰 값을 반환. fmax는 NaN 무시 |\n",
    "| minimum, fmin | 두 원소 중 작은 값 반환. fmin는 NaN 무시 |\n",
    "| mod | 첫번째 배열의 원소에 두번째 배열의 원소를 나눈 나머지 |\n",
    "| greater, greater_equal, less, less_equal, equal, not_equal | 두 원소 간의 >, >=, <, <=, ==, != 비교연산 결과를 불리언 배열로 반환 |\n",
    "| logical_and, logical_or, logical_xor | 각각 두 원소 간의 논리연산 결과를 반환 |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-15T03:57:29.230706Z",
     "start_time": "2021-03-15T03:57:29.217741Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 2.]\n",
      " [3. 4.]]\n",
      "[[5. 6.]\n",
      " [7. 8.]]\n"
     ]
    }
   ],
   "source": [
    "a2d = np.array([[1,2],[3,4]], dtype=np.float64)\n",
    "b2d = np.array([[5,6],[7,8]], dtype=np.float64)\n",
    "print(a2d)\n",
    "print(b2d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-15T03:57:29.245667Z",
     "start_time": "2021-03-15T03:57:29.231704Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 6.  8.]\n",
      " [10. 12.]]\n",
      "[[ 6.  8.]\n",
      " [10. 12.]]\n"
     ]
    }
   ],
   "source": [
    "# Elementwise sum; both produce the array\n",
    "print(a2d + b2d)\n",
    "print(np.add(a2d, b2d))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-15T03:57:29.260642Z",
     "start_time": "2021-03-15T03:57:29.248660Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-4. -4.]\n",
      " [-4. -4.]]\n",
      "[[-4. -4.]\n",
      " [-4. -4.]]\n"
     ]
    }
   ],
   "source": [
    "# Elementwise difference; both produce the array\n",
    "print(a2d - b2d)\n",
    "print(np.subtract(a2d, b2d))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-15T03:57:29.275586Z",
     "start_time": "2021-03-15T03:57:29.264620Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 5. 12.]\n",
      " [21. 32.]]\n",
      "[[ 5. 12.]\n",
      " [21. 32.]]\n"
     ]
    }
   ],
   "source": [
    "# Elementwise product; both produce the array\n",
    "print(a2d * b2d)\n",
    "print(np.multiply(a2d, b2d))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-15T03:57:29.290551Z",
     "start_time": "2021-03-15T03:57:29.276583Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.2        0.33333333]\n",
      " [0.42857143 0.5       ]]\n",
      "[[0.2        0.33333333]\n",
      " [0.42857143 0.5       ]]\n"
     ]
    }
   ],
   "source": [
    "# Elementwise division; both produce the array\n",
    "print(a2d / b2d)\n",
    "print(np.divide(a2d, b2d))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-15T03:57:29.305506Z",
     "start_time": "2021-03-15T03:57:29.293540Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1.         1.41421356]\n",
      " [1.73205081 2.        ]]\n"
     ]
    }
   ],
   "source": [
    "# Elementwise square root; produces the array\n",
    "print(np.sqrt(a2d))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-15T03:57:29.320466Z",
     "start_time": "2021-03-15T03:57:29.307501Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-1  2  3]\n",
      " [-4  5  6]\n",
      " [ 7  8 -9]]\n",
      "[[1 2 3]\n",
      " [4 5 6]\n",
      " [7 8 9]]\n"
     ]
    }
   ],
   "source": [
    "a2d = np.array([[-1,2,3],[-4,5,6],[7,8,-9]])\n",
    "print(a2d)\n",
    "print(np.abs(a2d))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-15T03:57:29.335427Z",
     "start_time": "2021-03-15T03:57:29.325462Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[       nan 1.41421356 1.73205081]\n",
      " [       nan 2.23606798 2.44948974]\n",
      " [2.64575131 2.82842712        nan]]\n",
      "[[       nan 1.41421356 1.73205081]\n",
      " [       nan 2.23606798 2.44948974]\n",
      " [2.64575131 2.82842712        nan]]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<ipython-input-20-9db782300436>:1: RuntimeWarning: invalid value encountered in sqrt\n",
      "  print(np.sqrt(a2d))\n",
      "<ipython-input-20-9db782300436>:3: RuntimeWarning: invalid value encountered in power\n",
      "  print(a2d**0.5)\n"
     ]
    }
   ],
   "source": [
    "print(np.sqrt(a2d))\n",
    "# is same as\n",
    "print(a2d**0.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-15T03:57:29.350391Z",
     "start_time": "2021-03-15T03:57:29.337421Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-1  1  1]\n",
      " [-1  1  1]\n",
      " [ 1  1 -1]]\n",
      "[[-1.  2.  3.]\n",
      " [-4.  5.  6.]\n",
      " [ 7.  8. -9.]]\n"
     ]
    }
   ],
   "source": [
    "print(np.sign(a2d))\n",
    "print(np.ceil(a2d))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-15T03:57:29.381305Z",
     "start_time": "2021-03-15T03:57:29.364353Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[False, False, False],\n",
       "       [False, False, False],\n",
       "       [False, False, False]])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.isnan(a2d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-15T03:57:29.411223Z",
     "start_time": "2021-03-15T03:57:29.389290Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[False, False, False],\n",
       "       [False, False, False],\n",
       "       [False, False, False]])"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.isinf(a2d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-15T03:57:29.441144Z",
     "start_time": "2021-03-15T03:57:29.415219Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ True,  True,  True],\n",
       "       [ True,  True,  True],\n",
       "       [ True,  True,  True]])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.isfinite(a2d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-15T03:57:29.456109Z",
     "start_time": "2021-03-15T03:57:29.443139Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.54030231, -0.41614684, -0.9899925 ],\n",
       "       [-0.65364362,  0.28366219,  0.96017029],\n",
       "       [ 0.75390225, -0.14550003, -0.91113026]])"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.cos(a2d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-15T03:57:29.471070Z",
     "start_time": "2021-03-15T03:57:29.462100Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[False, False, False],\n",
       "       [False, False, False],\n",
       "       [False, False, False]])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.logical_not(np.cos(a2d))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-15T03:57:29.486027Z",
     "start_time": "2021-03-15T03:57:29.472061Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-1.55740772, -2.18503986, -0.14254654],\n",
       "       [-1.15782128, -3.38051501, -0.29100619],\n",
       "       [ 0.87144798, -6.79971146,  0.45231566]])"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.tan(a2d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-15T03:57:29.500984Z",
     "start_time": "2021-03-15T03:57:29.492017Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[False, False, False],\n",
       "       [False, False, False],\n",
       "       [False, False, False]])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.logical_not(np.tan(a2d))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-15T03:57:29.515945Z",
     "start_time": "2021-03-15T03:57:29.505980Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-1  2  3]\n",
      " [-4  5  6]\n",
      " [ 7  8 -9]]\n",
      "[[1 2 3]\n",
      " [4 5 6]\n",
      " [7 8 9]]\n",
      "\n",
      "\n",
      "[[ 0  4  6]\n",
      " [ 0 10 12]\n",
      " [14 16  0]]\n",
      "[[ -1   4   9]\n",
      " [-16  25  36]\n",
      " [ 49  64 -81]]\n",
      "[[        -1          4         27]\n",
      " [       256       3125      46656]\n",
      " [    823543   16777216 -387420489]]\n",
      "[[ True False False]\n",
      " [ True False False]\n",
      " [False False  True]]\n",
      "[[False  True  True]\n",
      " [False  True  True]\n",
      " [ True  True False]]\n"
     ]
    }
   ],
   "source": [
    "b2d = np.array([[1,2,3],[4,5,6],[7,8,9]])\n",
    "print(a2d)\n",
    "print(b2d)\n",
    "print('\\n')\n",
    "print(np.add(a2d, b2d))\n",
    "print(np.multiply(a2d, b2d))\n",
    "print(np.power(a2d, b2d))\n",
    "print(np.greater(b2d, a2d))\n",
    "print(np.logical_and(a2d, a2d+b2d))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 배열  값 선택과 다루기\n",
    "\n",
    "- **슬라이싱(Slicing):** List와 유사한 방식으로 배열에 적용할 수 있으며 차이가 있다면 배열은 다차원 일 수 있으므로 배열의 각 차원에 대해 슬라이스를 사용함. 슬라이싱으로 값을 선택하면 결과의 차원은 원래의 차원보다 같거나 작음.\n",
    "\n",
    "- **정수 배열 인덱싱(Int Array Indexing):**  배열의 특정 위치에 있는 값으로 구성할 수 있음\n",
    "\n",
    "- **부울 배열 인덱싱(Boolean Array indexing):** 배열의 특정 값만 선택할 수 있으며, 일부 조건이 참인 경우의 값을 선택하는데 사용\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-15T03:57:29.530904Z",
     "start_time": "2021-03-15T03:57:29.519940Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2 3 4 5 6 7 8 9]\n",
      "5\n",
      "[5 6 7]\n"
     ]
    }
   ],
   "source": [
    "a = np.arange(10)\n",
    "print(a)\n",
    "print(a[5])\n",
    "print(a[5:8])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-15T03:57:29.546864Z",
     "start_time": "2021-03-15T03:57:29.532899Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1  2  3  4]\n",
      " [ 5  6  7  8]\n",
      " [ 9 10 11 12]]\n",
      "\n",
      "\n",
      "[5 6 7 8]\n",
      "[[5 6 7 8]]\n",
      "[[ 5  6  7  8]\n",
      " [ 9 10 11 12]]\n",
      "[[ 2  3]\n",
      " [ 6  7]\n",
      " [10 11]]\n"
     ]
    }
   ],
   "source": [
    "a = np.array([[1,2,3,4], [5,6,7,8], [9,10,11,12]])\n",
    "print(a)\n",
    "print('\\n')\n",
    "print(a[1,:])\n",
    "print(a[1:2,:])\n",
    "print(a[1:3,:])\n",
    "print(a[:,1:3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-15T03:57:29.576780Z",
     "start_time": "2021-03-15T03:57:29.548860Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2]\n",
      " [3 4]\n",
      " [5 6]]\n",
      "\n",
      "\n",
      "[1 4 5]\n",
      "[1 4 5]\n"
     ]
    }
   ],
   "source": [
    "a = np.array([[1,2], [3, 4], [5, 6]])\n",
    "print(a)\n",
    "print('\\n')\n",
    "print(a[[0, 1, 2], [0, 1, 0]])\n",
    "print(np.array([a[0, 0], a[1, 1], a[2, 0]]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-15T03:57:29.591746Z",
     "start_time": "2021-03-15T03:57:29.578781Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1  2  3]\n",
      " [ 4  5  6]\n",
      " [ 7  8  9]\n",
      " [10 11 12]]\n",
      "\n",
      "\n",
      "[0 2 0 1]\n",
      "\n",
      "\n",
      "[ 1  6  7 11]\n",
      "[11 16 17 21]\n"
     ]
    }
   ],
   "source": [
    "a = np.array([[1,2,3], [4,5,6], [7,8,9], [10, 11, 12]])\n",
    "print(a)\n",
    "print('\\n')\n",
    "b = np.array([0, 2, 0, 1])\n",
    "print(b)\n",
    "print('\\n')\n",
    "print(a[np.arange(4), b])\n",
    "print(a[np.arange(4), b] + 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-15T03:57:29.606700Z",
     "start_time": "2021-03-15T03:57:29.593737Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2]\n",
      " [3 4]\n",
      " [5 6]]\n",
      "[[False False]\n",
      " [ True  True]\n",
      " [ True  True]]\n",
      "[3 4 5 6]\n"
     ]
    }
   ],
   "source": [
    "a = np.array([[1,2], [3, 4], [5, 6]])\n",
    "print(a)\n",
    "print(a>2)\n",
    "print(a[a>2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-15T03:57:29.637620Z",
     "start_time": "2021-03-15T03:57:29.607699Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2 3 4 5 6 7 8 9]\n",
      "[  0   1   2   3   4 100 100 100   8   9]\n",
      "\n",
      "\n",
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# is similar as \"Python List\", but..\n",
    "a = np.arange(10)\n",
    "print(a)\n",
    "a[5:8] = 100\n",
    "print(a)\n",
    "print('\\n')\n",
    "\n",
    "b = list(range(10))\n",
    "print(b)\n",
    "# b[5:8] = 100\n",
    "# print(b)\n",
    "print('\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-15T03:57:29.652591Z",
     "start_time": "2021-03-15T03:57:29.638615Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['철수' '영희' '말자' '숙자']\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([ True, False, False, False])"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "names = np.array(['철수', '영희', '말자', '숙자'])\n",
    "print(names)\n",
    "names == '철수'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-15T03:57:29.667537Z",
     "start_time": "2021-03-15T03:57:29.656571Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1.68112177  0.55176234  1.08236379  0.71707106]\n",
      " [-0.13765235 -0.55331344  1.28958615  1.97134052]\n",
      " [ 0.24343877  0.45895648  1.22814409  0.0061167 ]\n",
      " [ 0.73632013  0.52797483 -0.59470445  0.34391626]]\n",
      "\n",
      "\n",
      "[[1.68112177 0.55176234 1.08236379 0.71707106]\n",
      " [0.         0.         1.28958615 1.97134052]\n",
      " [0.24343877 0.45895648 1.22814409 0.0061167 ]\n",
      " [0.73632013 0.52797483 0.         0.34391626]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[1.68112177, 0.55176234, 1.08236379, 0.71707106]])"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data = np.random.randn(4,4)\n",
    "print(data)\n",
    "print('\\n')\n",
    "data[data<0] = 0\n",
    "print(data)\n",
    "data[names == '철수']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-02-22T08:46:44.847002Z",
     "start_time": "2019-02-22T08:46:44.843004Z"
    }
   },
   "source": [
    "# Numpy 통계 함수"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-15T03:57:29.682497Z",
     "start_time": "2021-03-15T03:57:29.668536Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-1  2  3]\n",
      " [-4  5  6]\n",
      " [ 7  8 -9]]\n",
      "\n",
      "\n",
      "[[ 1  4  5]\n",
      " [-2  7  8]\n",
      " [ 9 10 -7]]\n",
      "[[ -2   4   6]\n",
      " [ -8  10  12]\n",
      " [ 14  16 -18]]\n"
     ]
    }
   ],
   "source": [
    "# Statistics\n",
    "a2d = np.array([[-1,2,3],[-4,5,6],[7,8,-9]])\n",
    "print(a2d)\n",
    "print('\\n')\n",
    "print(a2d + 2)\n",
    "print(a2d * 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-15T03:57:29.697457Z",
     "start_time": "2021-03-15T03:57:29.684493Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-1  2  3]\n",
      " [-4  5  6]\n",
      " [ 7  8 -9]]\n",
      "\n",
      "\n",
      "[ 2 15  0]\n",
      "[4 7 6]\n"
     ]
    }
   ],
   "source": [
    "print(a2d)\n",
    "print('\\n')\n",
    "print(np.sum(a2d, axis=0))\n",
    "print(np.sum(a2d, axis=1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-15T03:57:29.712419Z",
     "start_time": "2021-03-15T03:57:29.698455Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.66666667 5.         0.        ]\n",
      "[4.64279609 2.44948974 6.4807407 ]\n",
      "[21.55555556  6.         42.        ]\n",
      "[-4  2 -9]\n",
      "[7 8 6]\n"
     ]
    }
   ],
   "source": [
    "print(np.mean(a2d, axis=0))\n",
    "print(np.std(a2d, axis=0))\n",
    "print(np.var(a2d, axis=0))\n",
    "print(np.min(a2d, axis=0))\n",
    "print(np.max(a2d, axis=0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-15T03:57:29.727383Z",
     "start_time": "2021-03-15T03:57:29.715411Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-1  2  3]\n",
      " [-4  5  6]\n",
      " [ 7  8 -9]]\n",
      "\n",
      "\n",
      "[1 0 2]\n",
      "[2 2 1]\n"
     ]
    }
   ],
   "source": [
    "print(a2d)\n",
    "print('\\n')\n",
    "print(np.argmin(a2d, axis=0))\n",
    "print(np.argmax(a2d, axis=0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-15T03:57:29.742337Z",
     "start_time": "2021-03-15T03:57:29.729373Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-1  2  3]\n",
      " [-4  5  6]\n",
      " [ 7  8 -9]]\n",
      "\n",
      "\n",
      "[[-1  2  3]\n",
      " [-5  7  9]\n",
      " [ 2 15  0]]\n",
      "[[  -1    2    3]\n",
      " [   4   10   18]\n",
      " [  28   80 -162]]\n"
     ]
    }
   ],
   "source": [
    "print(a2d)\n",
    "print('\\n')\n",
    "print(np.cumsum(a2d, axis=0))\n",
    "print(np.cumprod(a2d, axis=0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-15T03:57:29.757302Z",
     "start_time": "2021-03-15T03:57:29.743335Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-1  2  3]\n",
      " [-4  5  6]\n",
      " [ 7  8 -9]]\n",
      "[[1 2 3]\n",
      " [4 5 6]\n",
      " [7 8 9]]\n",
      "\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[-1,  2,  3],\n",
       "       [-4,  5,  6],\n",
       "       [ 7,  8, -9],\n",
       "       [ 1,  2,  3],\n",
       "       [ 4,  5,  6],\n",
       "       [ 7,  8,  9]])"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a2d = np.array([[-1,2,3],[-4,5,6],[7,8,-9]])\n",
    "b2d = np.array([[1,2,3],[4,5,6],[7,8,9]])\n",
    "print(a2d)\n",
    "print(b2d)\n",
    "print('\\n')\n",
    "\n",
    "c2d = np.concatenate((a2d, b2d), axis=0)\n",
    "c2d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-15T03:57:29.772257Z",
     "start_time": "2021-03-15T03:57:29.759294Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-1,  2,  3,  1,  2,  3],\n",
       "       [-4,  5,  6,  4,  5,  6],\n",
       "       [ 7,  8, -9,  7,  8,  9]])"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c2d = np.concatenate((a2d, b2d), axis=1)\n",
    "c2d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-15T03:57:29.787217Z",
     "start_time": "2021-03-15T03:57:29.773256Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-1,  2],\n",
       "       [ 3,  1],\n",
       "       [ 2,  3],\n",
       "       [-4,  5],\n",
       "       [ 6,  4],\n",
       "       [ 5,  6],\n",
       "       [ 7,  8],\n",
       "       [-9,  7],\n",
       "       [ 8,  9]])"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c2d.reshape((9,2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-15T03:57:29.802177Z",
     "start_time": "2021-03-15T03:57:29.789221Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1  2  3  4]\n",
      " [ 5  6  7  8]\n",
      " [ 9 10 11 12]\n",
      " [13 14 15 16]]\n",
      "\n",
      "\n",
      "[array([[1, 2, 3, 4],\n",
      "       [5, 6, 7, 8]]), array([[ 9, 10, 11, 12],\n",
      "       [13, 14, 15, 16]])]\n"
     ]
    }
   ],
   "source": [
    "a2d = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13 ,14 ,15, 16]])\n",
    "print(a2d)\n",
    "print('\\n')\n",
    "print(np.split(a2d, 2, axis=0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-03-15T03:57:29.817144Z",
     "start_time": "2021-03-15T03:57:29.804177Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[array([[ 1,  2],\n",
      "       [ 5,  6],\n",
      "       [ 9, 10],\n",
      "       [13, 14]]), array([[ 3,  4],\n",
      "       [ 7,  8],\n",
      "       [11, 12],\n",
      "       [15, 16]])]\n"
     ]
    }
   ],
   "source": [
    "print(np.split(a2d, 2, axis=1))"
   ]
  }
 ],
 "metadata": {
  "hide_input": false,
  "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.8.5"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "314px"
   },
   "toc_section_display": true,
   "toc_window_display": true
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}