1_to_2.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "a5c7dad9-481d-466d-845c-660fb0bdf2cf",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "845f48f6-4e97-4aa0-af65-a5de32502cb1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "array1 type : <class 'numpy.ndarray'>\n",
      "array1 array 형태 : (3,)\n",
      "array2 type: <class 'numpy.ndarray'>\n",
      "array2 array 형태: (2, 3)\n",
      "array3 type: <class 'numpy.ndarray'>\n",
      "array3 array 형태: (1, 3)\n",
      "array1:1차원, array2:2차원, array3:2차원\n"
     ]
    }
   ],
   "source": [
    "#ndarray 개요(14~16page)\n",
    "array1 = np.array([1,2,3])\n",
    "print('array1 type :',type(array1))\n",
    "print('array1 array 형태 :', array1.shape)\n",
    "\n",
    "array2 = np.array([[1,2,3]\n",
    "                  ,[2,3,4]])\n",
    "print('array2 type:', type(array2))\n",
    "print('array2 array 형태:', array2.shape)\n",
    "\n",
    "array3 = np.array([[1,2,3]])\n",
    "print('array3 type:', type(array3))\n",
    "print('array3 array 형태:', array3.shape)\n",
    "\n",
    "print('array1:{0}차원, array2:{1}차원, array3:{2}차원'.format(array1.ndim, array2.ndim, array3.ndim))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "2c447c23-8818-4b2e-bff9-35dd0cabad5b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'list'>\n",
      "<class 'numpy.ndarray'>\n",
      "[1 2 3] int64\n"
     ]
    }
   ],
   "source": [
    "#ndarray 데이터 타입 (16~18page)\n",
    "list1 = [1,2,3]\n",
    "print(type(list1))\n",
    "array1= np.array(list1)\n",
    "print(type(array1))\n",
    "print(array1, array1.dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "1eadf8c4-1cfa-43ab-aac7-693bd070156f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['1' '2' 'test'] <U21\n",
      "[1. 2. 3.] float64\n"
     ]
    }
   ],
   "source": [
    "#다른 데이터 유형이 섞여 있는 리스트를 ndarray로 변경하면, 데이터 크기가 더 큰 데이터 타입으로 형 변환을 일괄 적용한다.\n",
    "list2 = [1,2,'test']\n",
    "array2 = np.array(list2)\n",
    "print(array2,array2.dtype)\n",
    "\n",
    "list3 = [1,2,3.0]\n",
    "array3 = np.array(list3)\n",
    "print(array3,array3.dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "a5c825e9-ff6f-4ae4-8c1b-edf79ba5f49e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1. 2. 3.] float64\n",
      "[1 2 3] int32\n",
      "[1 2 3] int32\n"
     ]
    }
   ],
   "source": [
    "#astype()으로 데이터값의 타입 변경 : 메모리를 더 절약해야할 때!\n",
    "array_int = np.array([1,2,3])\n",
    "array_float = array_int.astype('float64')\n",
    "print(array_float, array_float.dtype)\n",
    "\n",
    "array_int1 = array_float.astype('int32')\n",
    "print(array_int1, array_int1.dtype)\n",
    "\n",
    "array_float1 = np.array([1.1, 2.1, 3.1])\n",
    "array_int2 = array_float1.astype('int32')\n",
    "print(array_int2, array_int2.dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "ba8dd0d4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2 3 4 5 6 7 8 9]\n",
      "int64 (10,)\n"
     ]
    }
   ],
   "source": [
    "#ndarray를 편리하게 생성하기 - arange, zeros, ones\n",
    "sequence_array=np.arange(10)\n",
    "print(sequence_array)\n",
    "print(sequence_array.dtype, sequence_array.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "5ad75df9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 0]\n",
      " [0 0]\n",
      " [0 0]]\n",
      "int32 (3, 2)\n",
      "[[1. 1.]\n",
      " [1. 1.]\n",
      " [1. 1.]]\n",
      "float64 (3, 2)\n"
     ]
    }
   ],
   "source": [
    "zero_array = np.zeros((3,2), dtype='int32')\n",
    "print(zero_array)\n",
    "print(zero_array.dtype, zero_array.shape)\n",
    "\n",
    "one_array = np.ones((3,2))\n",
    "print(one_array)\n",
    "print(one_array.dtype, one_array.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "00a16716",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "array1:\n",
      " [0 1 2 3 4 5 6 7 8 9]\n",
      "array2\n",
      " [[0 1 2 3 4]\n",
      " [5 6 7 8 9]]\n",
      "array3\n",
      " [[0 1]\n",
      " [2 3]\n",
      " [4 5]\n",
      " [6 7]\n",
      " [8 9]]\n"
     ]
    }
   ],
   "source": [
    "# ndarray의 차원과 크기를 변경하는 reshape()\n",
    "array1 = np.arange(10)\n",
    "print('array1:\\n', array1)\n",
    "\n",
    "array2 = array1.reshape(2,5)\n",
    "print('array2\\n', array2)\n",
    "\n",
    "array3 = array1.reshape(5,2)\n",
    "print('array3\\n', array3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "d1e8e728",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2 3 4 5 6 7 8 9]\n",
      "array2 shape:  (2, 5)\n",
      "array3 shape: (5, 2)\n"
     ]
    }
   ],
   "source": [
    "array1 = np.arange(10)\n",
    "print(array1)\n",
    "array2 = array1.reshape(-1,5) # -1은 차원을 자동으로 계산하라는 의미\n",
    "print('array2 shape: ', array2.shape)\n",
    "array2 = array1.reshape(5,-1)\n",
    "print('array3 shape:' ,array2.shape)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "37236609",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "array3d:\n",
      " [[[0, 1], [2, 3]], [[4, 5], [6, 7]]]\n",
      "array5:\n",
      " [[0], [1], [2], [3], [4], [5], [6], [7]]\n",
      "array5 shape: (8, 1)\n",
      "array6:\n",
      " [[0], [1], [2], [3], [4], [5], [6], [7]]\n",
      "array6 shape :  (8, 1)\n"
     ]
    }
   ],
   "source": [
    "array1 = np.arange(8)\n",
    "array3d = array1.reshape((2,2,2))\n",
    "print('array3d:\\n', array3d.tolist())\n",
    "\n",
    "#3차원 ndarray를 2차원 ndarray로 변환\n",
    "array5 = array3d.reshape(-1,1)\n",
    "print('array5:\\n', array5.tolist())\n",
    "print('array5 shape:', array5.shape)\n",
    "\n",
    "#1차원 ndarray를 2차원 ndarray로 변환\n",
    "array6 = array1.reshape(-1,1)\n",
    "print('array6:\\n', array6.tolist())\n",
    "print('array6 shape : ', array6.shape)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "2dd19f18",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 넘파이의 ndarray의 데이터 세트 선택하기 - indexing\n",
    "\n",
    "# 특정한 데이터만 추출 : 원하는 위치의 인덱스 값을 지정하면 해당 위치의 데이터가 반환됩니다.\n",
    "# 슬라이싱 : ':' 기호 사이에 시작 인덱스와 종료 인덱스 표시\n",
    "# 팬시 인덱싱 : 일정한 인덱싱 집합을 리스트 또는 ndarray 형태로 지정해 해당 위치에 있는 데이터의 ndarray를 반환\n",
    "# 불린 인덱싱 : 특정 조건에 해당하는지 여부인 true/false 값 인덱싱 집합을 기반으로 true에 해당하는 인덱스 위치에 있는 데이터의 ndarray를 반환"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "b0ca7b31",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "array1: [1 2 3 4 5 6 7 8 9]\n",
      "value: 3\n",
      "<class 'numpy.int64'>\n"
     ]
    }
   ],
   "source": [
    "# 단일 값 추출\n",
    "\n",
    "#1부터 9까지의 1차원 ndarray 생성\n",
    "array1 = np.arange(start=1, stop=10)\n",
    "print('array1:', array1)\n",
    "\n",
    "value = array1[2]\n",
    "print('value:', value)\n",
    "print(type(value))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "a66efb09",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "맨 뒤의 값 :  9 맨 뒤에서 두 번째 값 :  8\n"
     ]
    }
   ],
   "source": [
    "print('맨 뒤의 값 : ', array1[-1], '맨 뒤에서 두 번째 값 : ', array1[-2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "ce068e84",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "array1: [9 2 3 4 5 6 7 8 0]\n"
     ]
    }
   ],
   "source": [
    "array1[0] = 9\n",
    "array1[8] = 0\n",
    "print('array1:', array1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "620fda21",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [4 5 6]\n",
      " [7 8 9]]\n",
      "(row=0, col=0) index 가리키는 값 1\n",
      "(row=0, col=1) index 가리키는 값 2\n",
      "(row=1, col=0) index 가리키는 값 4\n",
      "(row=2, col=2) index 가리키는 값 9\n"
     ]
    }
   ],
   "source": [
    "array1d = np.arange(start=1, stop=10)\n",
    "array2d = array1d.reshape(3,3)\n",
    "print(array2d)\n",
    "\n",
    "print('(row=0, col=0) index 가리키는 값', array2d[0,0]) # axis0=0, axis1=1 이 정확한 표현!\n",
    "print('(row=0, col=1) index 가리키는 값', array2d[0,1])\n",
    "print('(row=1, col=0) index 가리키는 값', array2d[1,0])\n",
    "print('(row=2, col=2) index 가리키는 값', array2d[2,2])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "49274a76",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3]\n",
      "<class 'numpy.ndarray'>\n"
     ]
    }
   ],
   "source": [
    "# 슬라이싱\n",
    "array1 = np.arange(start=1, stop=10)\n",
    "array3 = array1[0:3]\n",
    "print(array3)\n",
    "print(type(array3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "0002c669",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3]\n",
      "[4 5 6 7 8 9]\n",
      "[1 2 3 4 5 6 7 8 9]\n"
     ]
    }
   ],
   "source": [
    "array1 = np.arange(start=1, stop=10)\n",
    "array4 = array1[:3]\n",
    "print(array4)\n",
    "\n",
    "array5 = array1[3:]\n",
    "print(array5)\n",
    "\n",
    "array6 = array1[:]\n",
    "print(array6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "55582ecc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "array2d:\n",
      " [[1 2 3]\n",
      " [4 5 6]\n",
      " [7 8 9]]\n",
      "array2d[0:2, 0:2]\n",
      " [[1 2]\n",
      " [4 5]]\n",
      "array2d[1:3, 0:3]\n",
      " [[4 5 6]\n",
      " [7 8 9]]\n",
      "array2d[1:3, :]\n",
      " [[4 5 6]\n",
      " [7 8 9]]\n",
      "array2d[:, :]\n",
      " [[1 2 3]\n",
      " [4 5 6]\n",
      " [7 8 9]]\n",
      "array2d[:2, 1:]\n",
      " [[2 3]\n",
      " [5 6]]\n",
      "array2d[:2, 0]\n",
      " [1 4]\n"
     ]
    }
   ],
   "source": [
    "array1d = np.arange(start=1, stop=10)\n",
    "array2d = array1d.reshape(3,3)\n",
    "print('array2d:\\n', array2d)\n",
    "\n",
    "print('array2d[0:2, 0:2]\\n', array2d[0:2, 0:2])\n",
    "\n",
    "print('array2d[1:3, 0:3]\\n', array2d[1:3, 0:3])\n",
    "\n",
    "print('array2d[1:3, :]\\n', array2d[1:3, :])\n",
    "\n",
    "print('array2d[:, :]\\n', array2d[:, :])\n",
    "\n",
    "print('array2d[:2, 1:]\\n', array2d[:2, 1:])\n",
    "\n",
    "print('array2d[:2, 0]\\n', array2d[:2, 0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "65e46d3b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3]\n",
      "[4 5 6]\n",
      "array2d[0] shape :  (3,) array2d[1] shape (3,)\n"
     ]
    }
   ],
   "source": [
    "print(array2d[0])\n",
    "print(array2d[1])\n",
    "print('array2d[0] shape : ', array2d[0].shape, 'array2d[1] shape', array2d[1].shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "3e813802",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "array2d[[0,1],2]=> [3, 6]\n",
      "array2d[[0,1], 0:2] => [[1, 2], [4, 5]]\n",
      "array2d[[0,1]] =>  [[1, 2, 3], [4, 5, 6]]\n"
     ]
    }
   ],
   "source": [
    "# fancy indexing\n",
    "# 리스트나 ndarray로 인덱스 집합을 지정하면 해당 위치의 인덱스에 해당하는 ndarray를 반환하는 인덱싱 방식\n",
    "\n",
    "array1d = np.arange(start=1, stop=10)\n",
    "array2d = array1d.reshape(3,3)\n",
    "\n",
    "array3 = array2d[[0,1],2]\n",
    "print('array2d[[0,1],2]=>', array3.tolist())\n",
    "\n",
    "array4 = array2d[[0,1], 0:2]\n",
    "print('array2d[[0,1], 0:2] =>', array4.tolist())\n",
    "\n",
    "array5 = array2d[[0,1]]\n",
    "print('array2d[[0,1]] => ', array5.tolist())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "3ac62a43",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "array1d >5 불린 인덱싱 결과 값: [6 7 8 9]\n"
     ]
    }
   ],
   "source": [
    "array1d = np.arange(start=1, stop=10)\n",
    "# [  ] 안에 ㅁrray1d > 5 boolean indexing 적용\n",
    "array3 = array1d[array1d >5]\n",
    "print('array1d >5 불린 인덱싱 결과 값:', array3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "3dad7f66",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False, False, False, False, False,  True,  True,  True,  True])"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array1d > 5\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "5d6c4f8e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "불린 인덱스로 필터링 결과 :  [6 7 8 9]\n"
     ]
    }
   ],
   "source": [
    "boolean_indexes = np.array([False, False, False, False, False, True, True, True, True])\n",
    "array3 = array1d[boolean_indexes]\n",
    "print('불린 인덱스로 필터링 결과 : ', array3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "1f2a9936",
   "metadata": {},
   "outputs": [],
   "source": [
    "# step 1 : array1d >5 와 같이 ndarray의 필터링 조건을 []안에 기재\n",
    "# step 2 : false 값은 무시하고 true 값에 해당하는 인덱스 값만 저장 (true 값 자체인 1이 아니라 true 값을 가진 인덱스를 저장)\n",
    "# step 3 : 저장된 인덱스 데이터 세트로 ndarray 조회"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "7f501dd9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "원본 행렬 :  [3 1 9 5]\n",
      "np.sort() 호출 후 반환된 정렬 행렬 [1 3 5 9]\n",
      "np.sort() 호출 후 원본 행렬 :  [3 1 9 5]\n",
      "org_array.sort() 호출 후 반환된 행렬 :  None\n",
      "org_array.sort() 호출 후 원본 행렬 :  [1 3 5 9]\n"
     ]
    }
   ],
   "source": [
    "# 행렬의 정렬\n",
    "org_array = np.array([3,1,9,5])\n",
    "print('원본 행렬 : ', org_array)\n",
    "\n",
    "#np.sort로 정렬\n",
    "sort_array1 = np.sort(org_array)\n",
    "print('np.sort() 호출 후 반환된 정렬 행렬', sort_array1)\n",
    "print('np.sort() 호출 후 원본 행렬 : ', org_array) # np.sort()는 원본 행렬 그대로 유지!\n",
    "\n",
    "#ndarray.sort()로 정렬\n",
    "sort_array2 = org_array.sort()\n",
    "print('org_array.sort() 호출 후 반환된 행렬 : ', sort_array2) # 원 행렬 자체를 정렬한 형태로 변환하며 반환 값은 None\n",
    "print('org_array.sort() 호출 후 원본 행렬 : ', org_array)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "26a5a2f8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "내림차순으로 정렬: [9 5 3 1]\n"
     ]
    }
   ],
   "source": [
    "sort_array1_desc = np.sort(org_array)[::-1]\n",
    "print('내림차순으로 정렬:', sort_array1_desc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "850ce42f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "로우 방향으로 정렬 : \n",
      " [[ 7  1]\n",
      " [ 8 12]]\n",
      "칼럼 방향으로 정렬 : \n",
      " [[ 8 12]\n",
      " [ 1  7]]\n"
     ]
    }
   ],
   "source": [
    "array2d = np.array([[8,12],\n",
    "                    [7,1]])\n",
    "sort_array2d_axis0 = np.sort(array2d, axis=0) #세로 방향\n",
    "print('로우 방향으로 정렬 : \\n', sort_array2d_axis0)\n",
    "\n",
    "sort_array2d_axis1 = np.sort(array2d, axis=1)\n",
    "print('칼럼 방향으로 정렬 : \\n', sort_array2d_axis1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "0e95040f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'numpy.ndarray'>\n",
      "행렬 정렬 시 원본 행렬의 인덱스 :  [1 0 3 2]\n"
     ]
    }
   ],
   "source": [
    "org_array = np.array([3,1,9,5])\n",
    "sort_indices = np.argsort(org_array)\n",
    "print(type(sort_indices))\n",
    "print('행렬 정렬 시 원본 행렬의 인덱스 : ', sort_indices)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "13f4057c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "행렬 내림차순 정렬 시 원본 행렬의 인덱스 : [2 3 0 1]\n"
     ]
    }
   ],
   "source": [
    "org_array = np.array([3,1,9,5])\n",
    "sort_indices_desc = np.argsort(org_array)[::-1]\n",
    "print('행렬 내림차순 정렬 시 원본 행렬의 인덱스 :', sort_indices_desc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "89e178f2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "성적 오름차순 정렬 시  score_array의 인덱스 :  [0 2 4 1 3]\n",
      "성적 오름차순으로 name_array의 이름 출력 :  ['John' 'Sarah' 'Samuel' 'Mike' 'Kate']\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "name_array = np.array(['John', 'Mike', 'Sarah', 'Kate' ,'Samuel'])\n",
    "score_array = np.array([78,95,84,98,88])\n",
    "\n",
    "sort_indices_asc = np.argsort(score_array) # 기본은 오름차순\n",
    "print('성적 오름차순 정렬 시  score_array의 인덱스 : ', sort_indices_asc)\n",
    "print('성적 오름차순으로 name_array의 이름 출력 : ', name_array[sort_indices_asc])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "81d6f752",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "행렬 내적 결과 : \n",
      " [[ 58  64]\n",
      " [139 154]]\n"
     ]
    }
   ],
   "source": [
    "# 선형대수 연간 - 행렬 내적과 전치 행렬 구하기\n",
    "# 행렬 내적 : 행렬 곱\n",
    "\n",
    "A = np.array( [[1,2,3],\n",
    "               [4,5,6]])\n",
    "B= np.array([[7,8],\n",
    "             [9,10],\n",
    "             [11,12]])\n",
    "dot_product = np.dot(A,B)\n",
    "print('행렬 내적 결과 : \\n', dot_product)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "493b35fa",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A의 전치 행렬:\n",
      " [[1 3]\n",
      " [2 4]]\n"
     ]
    }
   ],
   "source": [
    "A = np.array([[1,2],\n",
    "             [3,4]])\n",
    "transpose_mat = np.transpose(A)\n",
    "print('A의 전치 행렬:\\n', transpose_mat)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "myenv",
   "language": "python",
   "name": "myenv"
  },
  "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.11.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}