실습파일-3/week4_practice.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'numpy.ndarray'>\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# ndarray 타입 생성\n",
    "import numpy as np\n",
    "a= np.array([1,2,3])\n",
    "print(type(a))\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3,)\n",
      "1\n",
      "int64\n",
      "8\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "print(a.shape)\n",
    "print(a.ndim) #차원\n",
    "print(a.dtype) #자료형\n",
    "print(a.itemsize) #int64는 8바이트\n",
    "print(a.size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "int32\n",
      "int64\n",
      "int64\n"
     ]
    }
   ],
   "source": [
    "# type 관련\n",
    "\n",
    "a = np.array([1,2,3] , dtype = 'int32')\n",
    "b = np.array([1,2,3] , dtype = 'int64')\n",
    "print(a.dtype)\n",
    "print(b.dtype)\n",
    "c = a + b\n",
    "# 작은타입과 큰타입이 더해지면 큰타입으로 자동 업캐스팅\n",
    "print(c.dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4]\n",
      "int64\n",
      "\n",
      "int32\n",
      "int32\n",
      "3\n",
      "1\n",
      "2.0\n"
     ]
    }
   ],
   "source": [
    "a = np.array([1,2,3,4])\n",
    "print(a)\n",
    "print(a.dtype)\n",
    "\n",
    "print()\n",
    "\n",
    "# type 지정하여 생성 가능\n",
    "a = np.array([1,2,3,4], dtype=np.int32)\n",
    "print(a.dtype)\n",
    "a = np.array([1,2,3,4], dtype='int32')\n",
    "print(a.dtype)\n",
    "\n",
    "a = np.array([1,2,3]) # 1차원 ndarray 배열 생성\n",
    "print(a.max()) # 가장 큰 값을 반환\n",
    "print(a.min()) # 가장 작은 값을 반환\n",
    "print(a.mean()) # 평균 값을 반환"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 1, 2, 2, 3, 3])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# flatten : ndarray의 모든 원소를 1차원 배열로 바꿈\n",
    "a = np.array([[1,1], [2,2], [3,3]])\n",
    "a\n",
    "a.flatten()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3],\n",
       "       [4, 5, 6],\n",
       "       [7, 8, 9]])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([1,2,3])\n",
    "b = np.array([[4,5,6], [7,8,9]])\n",
    "np.append(a,b)\n",
    "# 2차원 배열에서 axis 0은 행, 1은 열 (3차원에서는 0은 깊이, 1은 행, 2는 열)\n",
    "np.append([a], b, axis = 0) #[a]를 통해 2차원 배열로 만들어야 함"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([7, 9, 4, 6, 6, 8, 3, 9, 1, 6])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 난수 ndarray도 생성가능\n",
    "np.random.rand(3, 3)\n",
    "\n",
    "np.random.randint(0,10, size = 10) # 0에서 10사이의 10개의 난수생성"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([5, 7, 9])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([1,2,3])\n",
    "b = np.array([4,5,6])\n",
    "c = a + b\n",
    "c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "operands could not be broadcast together with shapes (2,) (3,) ",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[15], line 3\u001b[0m\n\u001b[1;32m      1\u001b[0m a \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39marray([\u001b[38;5;241m1\u001b[39m,\u001b[38;5;241m2\u001b[39m])\n\u001b[1;32m      2\u001b[0m b \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39marray([\u001b[38;5;241m4\u001b[39m,\u001b[38;5;241m5\u001b[39m,\u001b[38;5;241m6\u001b[39m])\n\u001b[0;32m----> 3\u001b[0m c \u001b[38;5;241m=\u001b[39m \u001b[43ma\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mb\u001b[49m\n",
      "\u001b[0;31mValueError\u001b[0m: operands could not be broadcast together with shapes (2,) (3,) "
     ]
    }
   ],
   "source": [
    "a = np.array([1,2])\n",
    "b = np.array([4,5,6])\n",
    "c = a + b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[11 22]\n",
      " [33 44]]\n",
      "[[ -9 -18]\n",
      " [-27 -36]]\n",
      "[[ 10  40]\n",
      " [ 90 160]]\n",
      "[[0.1 0.1]\n",
      " [0.1 0.1]]\n"
     ]
    }
   ],
   "source": [
    "a = np.array([[1,2],[3,4]])\n",
    "b = np.array([[10,20], [30,40]])\n",
    "print(a + b) # 덧셈\n",
    "print(a - b)# 뺄셈\n",
    "print(a * b) # 곱셈\n",
    "print(a / b) # 나눗셈"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 70 100]\n",
      " [150 220]]\n",
      "[[ 70 100]\n",
      " [150 220]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "np.int64(220)"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 행렬 곱\n",
    "print(np.matmul(a,b))\n",
    "print(a @ b)\n",
    "\n",
    "# a[0,0]*b[0,0] + a[0,1]*b[1,0]\n",
    "# a[0,0]*b[0,1] + a[0,1]*b[1,1]\n",
    "# a[1,0]*b[0,0] + a[1,1]*b[1,0]\n",
    "# a[1,0]*b[0,1] + a[1,1]*b[1,1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[2 3]\n",
      " [4 5]]\n",
      "[[0 1]\n",
      " [2 3]]\n",
      "[[100 200]\n",
      " [300 400]]\n",
      "[[0.01 0.02]\n",
      " [0.03 0.04]]\n",
      "[[ 1  4]\n",
      " [ 9 16]]\n"
     ]
    }
   ],
   "source": [
    "a = np.array([[1,2], [3,4]])\n",
    "print(a + 1) # 행렬의 각 성분에 대한 덧셈\n",
    "print(a - 1) # 행렬의 각 성분에 대한 뺄셈\n",
    "print(a * 100) # 행렬의 각 성분에 대한 곱셈\n",
    "print(a / 100) # 행렬의 각 성분에 대한 나눗셈\n",
    "print(a **2) # 행렬의 각 성분에 대한 제곱"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0. 0. 0.]\n",
      " [0. 0. 0.]]\n",
      "[[1. 1. 1.]\n",
      " [1. 1. 1.]]\n",
      "[[100 100 100]\n",
      " [100 100 100]]\n",
      "[[1. 0. 0.]\n",
      " [0. 1. 0.]\n",
      " [0. 0. 1.]]\n",
      "[[0.37052475 0.34204411 0.70214169]\n",
      " [0.87606733 0.75339746 0.67495357]]\n"
     ]
    }
   ],
   "source": [
    "print(np.zeros((2,3)))\n",
    "print(np.ones((2,3)))\n",
    "print(np.full((2,3), 100))\n",
    "print(np.eye(3))\n",
    "print(np.random.random((2,3)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2 3 4 5 6 7 8 9]\n",
      "[0 2 4 6 8]\n",
      "[0 3 6 9]\n",
      "[0.  0.2 0.4 0.6 0.8]\n"
     ]
    }
   ],
   "source": [
    "# np.arrange\n",
    "print(np.arange(0, 10))\n",
    "print(np.arange(0, 10, 2))\n",
    "print(np.arange(0, 10, 3))\n",
    "print(np.arange(0.0, 1.0, 0.2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0.   2.5  5.   7.5 10. ]\n",
      "[ 0.          3.33333333  6.66666667 10.        ]\n"
     ]
    }
   ],
   "source": [
    "# linspace(a,b,c)는 a부터 b수를 c구간만큼 나눔\n",
    "print(np.linspace(0, 10, 5))   #linspace = combination of the words 'linear' and 'space'\n",
    "print(np.linspace(0, 10, 4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 1 2 3 4]\n",
      " [5 6 7 8 9]]\n",
      "[[0 1]\n",
      " [2 3]\n",
      " [4 5]\n",
      " [6 7]\n",
      " [8 9]]\n",
      "[[[ 0  1]\n",
      "  [ 2  3]\n",
      "  [ 4  5]]\n",
      "\n",
      " [[ 6  7]\n",
      "  [ 8  9]\n",
      "  [10 11]]\n",
      "\n",
      " [[12 13]\n",
      "  [14 15]\n",
      "  [16 17]]\n",
      "\n",
      " [[18 19]\n",
      "  [20 21]\n",
      "  [22 23]]]\n",
      "[[0 1]\n",
      " [2 3]\n",
      " [4 5]]\n",
      "[[0 2 4]\n",
      " [1 3 5]]\n"
     ]
    }
   ],
   "source": [
    "print(np.arange(0,10).reshape(2,5)) #arange = array + range()\n",
    "print(np.arange(0,10).reshape(5,2))\n",
    "# print(np.arange(0,10).reshape(3,3)) # 3*3=9개여야 한다. 안그럼 에러\n",
    "\n",
    "print(np.arange(0, 24).reshape(4, 3, 2))\n",
    "\n",
    "a = np.arange(6).reshape(3,2)\n",
    "print(a)\n",
    "\n",
    "print(np.transpose(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 1]\n",
      " [2 3]\n",
      " [4 5]]\n",
      "15\n",
      "[6 9]\n",
      "[1 5 9]\n",
      "[0 1]\n",
      "[0 2 4]\n",
      "[4 5]\n",
      "[1 3 5]\n"
     ]
    }
   ],
   "source": [
    "# 4-2\n",
    "import numpy as np\n",
    "\n",
    "a = np.arange(0,6).reshape(3,2)\n",
    "print(a)\n",
    "\n",
    "print(a.sum()) # 행렬의 모든 원소의 합\n",
    "print(a.sum(axis = 0)) # 0축 방향(행 방향) 원소의 합\n",
    "print(a.sum(axis = 1)) # 1축 방향(열 방향) 원소의 합\n",
    "\n",
    "print(a.min(axis = 0)) # 0축 방향 원소의 최솟값\n",
    "print(a.min(axis = 1)) # 1축 방향 원소의 최솟값\n",
    "print(a.max(axis = 0)) # 0축 방향 원소의 최댓값\n",
    "print(a.max(axis = 1)) # 1축 방향 원소의 최댓값"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 3 4]\n",
      "[1 2 3 4]\n",
      "\n",
      "[[1 1]\n",
      " [2 2]\n",
      " [3 3]]\n",
      "[[1 1]\n",
      " [4 4]\n",
      " [2 2]\n",
      " [3 3]]\n",
      "\n",
      "[[1 4 1]\n",
      " [2 4 2]\n",
      " [3 4 3]]\n",
      "\n",
      "1 2 3\n",
      "3 2 1\n",
      "\n",
      "[1 2]\n",
      "[1 2 3]\n",
      "[1 2 4]\n",
      "[2 2 2 2]\n",
      "[1 5]\n"
     ]
    }
   ],
   "source": [
    "# np.insert는 a배열을 변경하지는 않는다.\n",
    "a = np.array([1,3,4])\n",
    "print(a)\n",
    "print(np.insert(a,1,2))\n",
    "print()\n",
    "# 행의 1번째 인덱스에 4 추가하기\n",
    "a = np.array([[1,1], [2,2], [3,3]])\n",
    "print(a)\n",
    "print(np.insert(a, 1, 4, axis = 0))\n",
    "print()\n",
    "# 열의 1번째 인덱스에 4 추가하기\n",
    "print(np.insert(a, 1, 4, axis = 1))\n",
    "print()\n",
    "# -1은 뒤에서 첫번째 인덱스\n",
    "a = np.array([1,2,3])\n",
    "print(a[0], a[1], a[2])\n",
    "print(a[-1], a[-2], a[-3])\n",
    "print()\n",
    "# 특정 인덱스를 지정하여 출력가능\n",
    "a = np.array([1,2,3,4,5])\n",
    "print(a[np.array([0,1])])\n",
    "print(a[np.array([0,1,2])])\n",
    "print(a[np.array([0,1,3])])\n",
    "print(a[np.array([1,1,1,1])])\n",
    "print(a[[0,4]]) #대충 이거랑 같은 뜻"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[20 30 40 50]\n",
      "[20 30 40 50 60 70 80]\n"
     ]
    }
   ],
   "source": [
    "# 슬라이싱\n",
    "a = np.array([10, 20, 30, 40, 50, 60, 70, 80])\n",
    "print(a[1:5]) # 슬라이싱 구간 [시작:끝] 인덱스, 새로운 ndarray 객체 생성이 아닌 기존 ndarray 객체를 참조 \n",
    "print(a[1:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 1]\n",
      " [2 3]\n",
      " [4 5]]\n",
      "0\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "a = np.arange(0,6).reshape(3,2)\n",
    "print(a)\n",
    "print(a[0,0])\n",
    "print(a[0,1])\n",
    "# print(a[0,2]) #error : 0번째행의 2번째 인덱스 값이 존재 하지 않음."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[ 0  1]\n",
      "  [ 2  3]\n",
      "  [ 4  5]]\n",
      "\n",
      " [[ 6  7]\n",
      "  [ 8  9]\n",
      "  [10 11]]\n",
      "\n",
      " [[12 13]\n",
      "  [14 15]\n",
      "  [16 17]]\n",
      "\n",
      " [[18 19]\n",
      "  [20 21]\n",
      "  [22 23]]]\n",
      "11\n"
     ]
    }
   ],
   "source": [
    "a = np.arange(0,24).reshape(4, 3, 2)\n",
    "print(a)\n",
    "# 3차원 배열의 첫번째 깊이의 2번째 행의 1번째 열 출력\n",
    "print(a[1, 2, 1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[ 0  1]\n",
      "  [ 2  3]\n",
      "  [ 4  5]]\n",
      "\n",
      " [[ 6  7]\n",
      "  [ 8  9]\n",
      "  [10 11]]\n",
      "\n",
      " [[12 13]\n",
      "  [14 15]\n",
      "  [16 17]]\n",
      "\n",
      " [[18 19]\n",
      "  [20 21]\n",
      "  [22 23]]]\n",
      "\n",
      "[[0 1]\n",
      " [2 3]\n",
      " [4 5]]\n",
      "\n",
      "[0 1]\n",
      "[2 3]\n",
      "[4 5]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([0, 1, 4, 5])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.arange(0,24).reshape(4, 3, 2)\n",
    "print(a)\n",
    "print()\n",
    "# 3차원 배열의 0번째 행렬 출력\n",
    "print(a[0])\n",
    "print()\n",
    "# 3차원 배열의 0번째 행렬의 0,1,2번째 행 출력\n",
    "print(a[0,0])\n",
    "print(a[0,1])\n",
    "print(a[0,2])\n",
    "# 1차원 배열 두 개를 합침 (axis=1은 에러)\n",
    "np.concatenate((a[0,0], a[0,2]), axis = 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 1 2]\n",
      " [3 4 5]\n",
      " [6 7 8]]\n",
      "\n",
      "[0 1 2]\n",
      "[0 1 2]\n",
      "[0 3 6]\n"
     ]
    }
   ],
   "source": [
    "a = np.arange(0,9).reshape(3,3)\n",
    "print(a)\n",
    "print()\n",
    "\n",
    "print(a[0]) # 첫 번째 행 불러오기1\n",
    "print(a[0, :]) # 첫 번째 행 불러오기2\n",
    "print(a[:, 0]) # 첫 번째 열 불러오기"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 1 2]\n",
      " [3 4 5]\n",
      " [6 7 8]]\n",
      "\n",
      "[0 1]\n",
      "[0 1]\n",
      "\n",
      "[[0 1]\n",
      " [3 4]]\n",
      "[[0 1]\n",
      " [3 4]]\n"
     ]
    }
   ],
   "source": [
    "print(a)\n",
    "print()\n",
    "\n",
    "# 0번째 행의 0~1컬럼\n",
    "print(a[0, 0:2])\n",
    "print(a[0, :2])\n",
    "print()\n",
    "\n",
    "# 0~1번째 행과 각각 0~1번째 컬럼\n",
    "print(a[0:2, 0:2])\n",
    "print(a[:2, :2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 1 2]\n",
      " [3 4 5]\n",
      " [6 7 8]]\n",
      "\n",
      "(2,)\n",
      "(1, 2)\n"
     ]
    }
   ],
   "source": [
    "print(a)\n",
    "print()\n",
    "\n",
    "print(a[1, 1:].shape)\n",
    "print(a[1:2, 1:].shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 2. -1.]\n"
     ]
    }
   ],
   "source": [
    "# 선형 방정식 풀기, 2x+3y=1, x-2y=4 풀기\n",
    "a = np.array([[2,3], [1,-2]])\n",
    "b = np.array([1,4])\n",
    "x = np.linalg.solve(a,b)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "np.float64(0.0)"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 행렬의 determinant 구하기\n",
    "a = np.array([[1,2], [3,4]])\n",
    "np.linalg.det(a)\n",
    "b = np.array([[1,2], [3,-6]])\n",
    "np.linalg.det(b)\n",
    "b = np.array([[1,2], [1,2]])\n",
    "np.linalg.det(b)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "myenv",
   "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"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}