ch01_머신러닝_넘파이.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "collapsed_sections": [],
      "authorship_tag": "ABX9TyO0YAbVcYUaxE3Fho0sVZEV",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/wlsisl/ESAA_22-2/blob/main/assignment2.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "S4fHTScAmTuR"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "##CHAPTER 01 _  파이썬 기반의 머신러닝과 생태계 이해\n",
        "####01.머신러닝의 개념\n",
        "\n",
        "\n",
        "* 머신러닝(Machine Learning)\n",
        "\n",
        "애플리케이션을 수정하지 않고도 데이터를 기반으로 패턴을 학습하고 결과를 예측하는 알고리즘 기법을 통칭한다.\n",
        "\n",
        "ex) 금융 사기 거래 적발 프로그램\n",
        "\n",
        "문제점: 프로그램 로직을 통해 모든 조건과 다양한 환경 변수, 규칙을 반영하여 사기 거래 적발의 정확성을 높여야하는데, 코드가 복잡할 수록 정확성이 떨어진다. \n",
        "업무적으로 복잡한 조건과 규칙들이 다양한 형태로 결합하고 시시각각 변하면서 소프트웨어 코드 로직을 관통하는 패턴을 찾기 어려움\n",
        "\n",
        "해결방안: 데이터를 기반으로 숨겨진 패턴을 인지해 해결한다. 머신러닝 알고리즘은 통계적 신뢰도를 강화하고 예측 오류를 최소화하기 위한 다양한 수학적 기법으로 패턴을 스스로 인지하고 신뢰도 있는 예측 결과를 도출함. \n",
        "\n",
        "\n",
        "* 머신러닝의 분류\n",
        "\n",
        "1. 지도학습\n",
        " 분류, 회귀, 추천 시스템, 시각/음성 감지/ 인지, 텍스트 분석, NLP\n",
        "\n",
        "2. 비지도학습\n",
        " 클러스터링, 차원 축소, 강화학습\n",
        "\n",
        "\n",
        "* 데이터 전쟁 \n",
        "최적의 머신러닝 알고리즘 , 모델 파라미터를 구축하는 능력뿐만 아니라\n",
        "데이터를 이해하고 효율적으로 가공, 처리, 추출해 최적의 데이터를 기반으로 알고리즘을 구동할 수 있도록 준비하는 능력이 중요하다.\n",
        "\n",
        "* 파이썬과 R기반의 머신러닝 비교\n",
        "\n",
        "1. R\n",
        "통계 전용 프로그램 언어. \n",
        "\n",
        "2. Python\n",
        "다양한 영역에서 사용되는 개발 전문 프로그램 언어.\n",
        "직관적인 문법, 객체지향과 함수형 프로그래밍\n",
        "아키텍처, 다양한 라이브러리\n",
        "\n",
        "####02.파이썬 머신러닝 생태계를 구성하는 주요 패키지\n",
        "\n",
        "* 머신러닝 패키지 - 사이킷런(Scikit-Learn)\n",
        "* 행렬/ 선형대수/ 통계 패키지 - 넘파이(Numpy), 사이파이(SciPy)\n",
        "* 데이터 핸들링 - 판다스\n",
        "* 시각화 - 맷플롯립(Matplotlib), 사본(Seaborn)\n",
        "\n",
        "####03. 넘파이\n"
      ],
      "metadata": {
        "id": "s3prxZzCmlaY"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "# as np를 약어로 모듈 표현함\n",
        "# numpy 기반 데이터 타입은 ndarray. 다차원 배열을 쉽게 생성하고 연산 수행가능"
      ],
      "metadata": {
        "id": "q4Di3zMrtdzX"
      },
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "array()함수: 다양한 인자를 입력 받아서 ndarray로 변환하는 기능을 수행함.\n"
      ],
      "metadata": {
        "id": "C6sbPLt1tyCb"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "array1=np.array([1,2,3])\n",
        "print('array1 type:', type(array1))\n",
        "print('array1 array 형태:', array1.shape)\n",
        "#1차원 array로 3개의 데이터를 가지고 있음을 뜻한다.\n",
        "\n",
        "array2 = np.array([[1,2,3],[2,3,4]])\n",
        "print('array2 type:', type(array2))\n",
        "print('array2 array형태:', array2.shape)\n",
        "#2차원 array로 2개의 로우와 3개의 칼럼으로 구성되어 6개의 데이터를 가지고 있음을 뜻한다.\n",
        "\n",
        "array3= np.array([[1,2,3]])\n",
        "print('array3 type:', type(array3))\n",
        "print('array3 array형태:', array3.shape)\n",
        "# 1개의 로우와 3개의 칼럼으로 구성된 2차원 데이터다."
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Vyt58PgUwaZ4",
        "outputId": "67763290-f303-4de2-df58-0f8368080f5c"
      },
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "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"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "이해한 내용) array 배열을 나타낼 때 numpy 에선 type이 ndarray임. 그리고 shape는 행과 열을 튜플()형태로 뽑아냄. \n",
        "\n",
        "1차원일 때는 (데이터 개수,) 이렇게 표현함.\n",
        "2차원일 때 (행,열) 을 나타냄.\n",
        "\n",
        "[1,2,3]은 1차원일거고 [[1,2,3]]은 2차원임!"
      ],
      "metadata": {
        "id": "BFCM-lA-3pfO"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print('array1:{:0}차원, array2: {:1}차원, array3: {:2}차원 '.format(array1.ndim,array2.ndim,array3.ndim))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XBZ5teB4xWoz",
        "outputId": "e3205286-1aeb-4537-ef0e-11034b745151"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "array1:1차원, array2: 2차원, array3:  2차원 \n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "ndarray의 데이터 타입\n",
        "* 같은 데이터 타입만 가능하다. 한 개의 ndarray객체에 int와 float가 함께 있을 수 없다. "
      ],
      "metadata": {
        "id": "RMFq7ClLxy3i"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "list1=[1,2,3]\n",
        "print(type(list1))\n",
        "array1=np.array(list1)\n",
        "print(type(array1))\n",
        "print(array1, array1.dtype)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TxXXzTvsxXH6",
        "outputId": "f9479d55-2a4e-44d7-c6ae-eca4e3cd2ca8"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<class 'list'>\n",
            "<class 'numpy.ndarray'>\n",
            "[1 2 3] int64\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#다른 데이터 타입이 함께 쓰인다면?\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)\n",
        "\n",
        "# int형 <float형  < 문자형"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "iqPR25W2xXkE",
        "outputId": "422901e4-5ee0-4678-b5cb-6c05c10666c2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['1' '2' 'test'] <U21\n",
            "[1. 2. 3.] float64\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "array_int=np.array([1,2,3])\n",
        "arfloatray_=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)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZsL3Dp-70EIF",
        "outputId": "40be6dbe-77af-4663-879c-12b823f3b59f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1. 2. 3.] float64\n",
            "[1 2 3] int32\n",
            "[1 2 3] int32\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "이해한 내용) 리스트는 다른 타입들이 같이 쓰일 수 있지만 행렬은 안 됨. 그래서 타입이 하나로 결정력 높은 것이 결정됨. 또, .astype 해주면 타입 변환 해주는 것임\n",
        "int형이 float보다 메모리를 절약함."
      ],
      "metadata": {
        "id": "KBj6PLQZ418M"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "ndarray를 편리하게 생성하기 - arange, zeros, ones\n",
        "- 테스트용으로 데이터를 만들거나 대규모의 데이터를 일괄적으로 초기화해야 할 경우에 사용\n",
        "\n",
        "* zeros() 튜플 형태의 shape 값을 입력하면 모든 값을 0으로 채운 해당 shape를 가진 ndarray를 반환한다. \n",
        "\n",
        "* ones() 튜플 형태의 shape 값을 입력하면 모든 값을 1로 채운 해당 shape를 가진 ndarray를 반환한다.\n",
        "\n",
        "dtype를 정해주지 않으면 default로 float64형의 데이터로 ndarray를 채운다."
      ],
      "metadata": {
        "id": "RSZ5zkNA7brO"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "sequence_array=np.arange(10)\n",
        "print(sequence_array)\n",
        "print(sequence_array.dtype, sequence_array.shape)\n",
        "# 이해한내용) arange하면 0부터 10-1까지 연속 숫자 값으로 구성된 1차원! ndarray를 만듦."
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LrpmHm0J7cXY",
        "outputId": "e5fa51a2-8997-4cac-d306-f7f132f2e214"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[0 1 2 3 4 5 6 7 8 9]\n",
            "int64 (10,)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "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)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_Ty9Vyps7cgh",
        "outputId": "6deadd02-a555-407f-b51d-53422169e885"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "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"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "ndarray의 차원과 크기를 변경하는 reshape()"
      ],
      "metadata": {
        "id": "8vAWzyCJ-47C"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "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)\n",
        "\n",
        "#이해한내용) arange로 1차원만 만들 수 있었는데 reshape로 행과 열을 지정해줘서 2차원이 되게 함."
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LAx1Mlpx7clu",
        "outputId": "3063c1ef-8e5d-4ab2-e5fd-c278873b4892"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "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"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "array1.reshape(4,3)\n",
        "#지정된 사이즈로 변경이 불가능하면 오류를 발생한다."
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 166
        },
        "id": "xdHN1XZ37cy2",
        "outputId": "3da95ed7-6bb6-4f6e-8849-47668bb7e28d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "ValueError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-21-a40469ec5825>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0marray1\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mreshape\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mValueError\u001b[0m: cannot reshape array of size 10 into shape (4,3)"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "array1=np.arange(10) #1차원\n",
        "print(array1)\n",
        "\n",
        "array2=array1.reshape(-1,5) # array1과 호환될 수 있는 2차원 ndarray로 변환하되,\n",
        "# 고정된 5개 칼럼에 맞는 로우 개수는 2이므로 2x5의 2차원으로 변환함.\n",
        "print('array2 shape:',array2.shape)\n",
        "\n",
        "array3=array1.reshape(5,-1)\n",
        "print('array3 shape:',array3.shape)\n",
        "print(array3)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "O1fMvPSq0E6b",
        "outputId": "381c7168-f3d6-4fcd-d064-e82db0f4086a"
      },
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[0 1 2 3 4 5 6 7 8 9]\n",
            "array2 shape: (2, 5)\n",
            "array3 shape: (5, 2)\n",
            "[[0 1]\n",
            " [2 3]\n",
            " [4 5]\n",
            " [6 7]\n",
            " [8 9]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "array1=np.arange(10)\n",
        "array4=array1.reshape(-1,4)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 184
        },
        "id": "1PrF1tlc0Fa7",
        "outputId": "4fb80063-a7f7-4a29-fa6a-7874f324bec3"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "ValueError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-23-7f01f0f59baa>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0marray1\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m10\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0marray4\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0marray1\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mreshape\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mValueError\u001b[0m: cannot reshape array of size 10 into shape (4)"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# <reshape(-1,1)로 차원 변경하기>\n",
        "\n",
        "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)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VEQpbKrfAm5s",
        "outputId": "eb59ed73-4636-4224-b3f0-8484b41e5f78"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "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"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "넘파이의 ndarray의 데이터 세트 선택하기 - 인덱싱(indexing)\n",
        "1. 특정한 데이터만 추출\n",
        "2. 슬라이싱\n",
        "3. 팬시 인덱싱\n",
        "4. 불린 인덱싱"
      ],
      "metadata": {
        "id": "tYJA8_wEAph7"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# 단일 값 추출\n",
        "\n",
        "#1부터 9까지의 1차원 ndarray생성\n",
        "\n",
        "array1=np.arange(start=1, stop=10)\n",
        "print('array1:',array1)\n",
        "\n",
        "#index는 0부터 시작하므로 array1[2]는 3번재 index위치의 데이터값을 의미\n",
        "value=array1[2]\n",
        "print('value:',value)\n",
        "print(type(value))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "r_It0xqGAnMN",
        "outputId": "f8dfa2d9-284e-442d-d3cc-f2d34851fcc4"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "array1: [1 2 3 4 5 6 7 8 9]\n",
            "value: 3\n",
            "<class 'numpy.int64'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print('맨 뒤의 값:',array1[-1], '맨 뒤에서 두번째값:', array1[-2])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Fa2no5VzAnO_",
        "outputId": "68844fde-3159-42c3-9626-0f02f397640f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "맨 뒤의 값: 9 맨 뒤에서 두번째값: 8\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "array1[0]=9\n",
        "array1[8]=0\n",
        "print('array1:',array1)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YiI6KVxMAnRS",
        "outputId": "6572e70a-8cf7-4a78-f906-9cb9a2a40695"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "array1: [9 2 3 4 5 6 7 8 0]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "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])\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",
        "\n",
        "#넘파이에서는 row 가 아니라 axis0으로 나타냄 , axis1은 col임"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cSQqas1CAnT1",
        "outputId": "513e1ecb-0116-4abb-eb0c-1d0d95e9955e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "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"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "슬라이싱\n",
        "1. [:3] 맨 처음부터 index3까지\n",
        "2. [3:] index3부터 맨 마지막 인덱스까지"
      ],
      "metadata": {
        "id": "bWEt8m5VJOXP"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "array1=np.arange(start=1, stop=10)\n",
        "array3=array1[0:3]\n",
        "print(array3)\n",
        "print(type(array3))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SuWPOpNeAnWI",
        "outputId": "cdaa9454-5060-4589-8959-ee9f1775007f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1 2 3]\n",
            "<class 'numpy.ndarray'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "array1d=np.arange(start=1, stop=10)\n",
        "array2d=array1d.reshape(3,3)\n",
        "print('array2d:\\n',array2)\n",
        "\n",
        "print('array2d[0:2,0:2]\\n', array2d[0:2, 0:2])\n",
        "print('array2d[1:3,0:3]\\n', array2d[1:3,0:3])\n",
        "print('array2d[1:3,:]\\n', array2d[1:3,:])\n",
        "print('array2d[:,:]\\n', array2d[:,:])\n",
        "print('array2d[:2,1:]\\n', array2d[:2,1:])\n",
        "print('array2d[:2,0]\\n', array2d[:2,0])"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "p-6pjDFPAnYS",
        "outputId": "05960d5e-2c8f-442f-a9a9-7fa75ba3df95"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "array2d:\n",
            " [[0 1 2 3 4]\n",
            " [5 6 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"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#2차원 ndarray에서 뒤에오는 인덱스를 없애면 1차원을 반환함. \n",
        "# ???low만 되는 것일까?\n",
        "\n",
        "print(array2d[0])\n",
        "print(array2d[1])\n",
        "print('array2d[0] shape:', array2d[0].shape, 'array2d[1].shape:', array2d[1].shape)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nPnoi-MwJQma",
        "outputId": "8abdbbd5-6ef5-4203-d397-e079d387915a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1 2 3]\n",
            "[4 5 6]\n",
            "array2d[0] shape: (3,) array2d[1].shape: (3,)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "팬시 인덱싱"
      ],
      "metadata": {
        "id": "-3GdwiEJK0-m"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "array1d= np.arange(start=1, stop=10)\n",
        "array2d=array1d.reshape(3,3)\n",
        "\n",
        "print(array2d)\n",
        "\n",
        "array3=array2d[[0,1],2]\n",
        "print('array2d[[0,1],2]=>', array3.tolist())  #??? [[3],[6]] 아님?\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())"
      ],
      "metadata": {
        "id": "jAnFZ2hPJQrc",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "96fa4482-f0ae-4a69-8bd6-2060fcc5ab78"
      },
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[1 2 3]\n",
            " [4 5 6]\n",
            " [7 8 9]]\n",
            "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"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "불린 인덱싱"
      ],
      "metadata": {
        "id": "7aPcXS7ulCKv"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "array1d = np.arange(start=1, stop=10)\n",
        "#[] 안에 array1d > 5 Boolean indexing을 적용\n",
        "\n",
        "array3=array1d[array1d>5]\n",
        "print('array1d > 5 불린 인덱싱 결과 값:', array3)\n"
      ],
      "metadata": {
        "id": "hwZVeJgFJQzr",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ddd9aac8-ebe6-45e2-d6b1-48d2ef9b5b21"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "array1d > 5 불린 인덱싱 결과 값: [6 7 8 9]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "array1d > 5"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "sILgdvR7lW-c",
        "outputId": "8cdaabc3-cf0b-4b9e-e439-a9636ac19343"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([False, False, False, False, False,  True,  True,  True,  True])"
            ]
          },
          "metadata": {},
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "boolean_indexes = np.array([False, False, False, False, False,  True,  True,  True,  True])\n",
        "array3=array1d[boolean_indexes]\n",
        "print('불린 인덱스로 필터링 결과:', array3)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zRRhUjq5lXQ_",
        "outputId": "8f973058-9fc7-496a-c0a2-e0caaa768ade"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "불린 인덱스로 필터링 결과: [6 7 8 9]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "indexes = np.array([5,6,7,8])\n",
        "array4 = array1d[indexes]\n",
        "print('일반 인덱스로 필터링 결과:',array4)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "X3f_dePilXTq",
        "outputId": "1b497e61-8caf-4626-f7b1-873723694e8e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "일반 인덱스로 필터링 결과: [6 7 8 9]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "행렬의 정렬 - sort()와 argsort()\n",
        "\n",
        "\n",
        "> \n",
        "\n",
        "1. 넘파이에서 행렬을 정렬하는 대표적인 방법: np.sort() , ndarray.sort() \n",
        "\n",
        "> 이해한내용) 둘의 차이점은? np를 사용하면 원 행렬은 그대로 유지하고 원행렬의 정렬된 행렬을 반환함. ndarray를 사용하면 행렬 자체를 정렬한 형태로 반환하며 반환 값은 none임. \n",
        "즉!! np는 새 값을 만들어주는 거고 ndarray는 갱신을 시켜버림.\n",
        "\n",
        "2. 행렬의 인덱스를 반환하는 argsort()"
      ],
      "metadata": {
        "id": "EGPFvSCJpNo2"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "org_array = np.array([3,1,9,5])\n",
        "print('원본 행렬:', org_array)\n",
        "# np.sort()로 정렬\n",
        "sort_array1=np.sort(org_array)\n",
        "print('np.sort() 호출 후 반환된 정렬 행렬:',sort_array1)\n",
        "print('np.sort() 호출 후 원본 행렬:',org_array)\n",
        "#ndarray.sort()로 정렬\n",
        "sort_array2 = org_array.sort()\n",
        "print('org_array.sort() 호출 후 반환된 행렬:',sort_array2)\n",
        "print('org_array.sort() 호출 후 원본 행렬:',org_array)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "uU_Yn3PhlXWG",
        "outputId": "b74f3ea0-f551-4011-e7f1-838ca9c070d2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "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"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "sort_array1_desc=np.sort(org_array)[::-1]\n",
        "print('내림차순으로 정렬:', sort_array1_desc)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MVUOa0MtlXZA",
        "outputId": "848a66db-b0cb-4ca1-f33d-0df21c049405"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "내림차순으로 정렬: [9 5 3 1]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#행렬이 2차원 이상일 경우에\n",
        "array2d = np.array([[8,12],[7,1]])\n",
        "\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)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Wo2XfdWClXbf",
        "outputId": "75f0a359-1c9c-4a6d-91c7-4742f8b4fb40"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "로우 방향으로 정렬 : \n",
            " [[ 7  1]\n",
            " [ 8 12]]\n",
            "칼럼 방향으로 정렬 : \n",
            " [[ 8 12]\n",
            " [ 1  7]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "\n"
      ],
      "metadata": {
        "id": "H2Q3Y3LFlXdp"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "정렬된 행렬의 인덱스를 반환하기\n",
        "\n",
        "np.argsort() 정렬 행렬의 원본 행렬 인덱스를 ndarray형으로 반환\n",
        "\n",
        "1. 오름차순으로 정렬하고 인덱스 반환하는 것"
      ],
      "metadata": {
        "id": "DqQ8dCz0u5UC"
      }
    },
    {
      "cell_type": "code",
      "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)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "goqLkNE6lXhN",
        "outputId": "b171e3e7-139a-4820-cae3-6ed7d05565a4"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<class 'numpy.ndarray'>\n",
            "행렬 정렬 시 원본 행렬의 인덱스: [1 0 3 2]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "2. 내림차순으로 정렬하고 인덱스 반환하는 것"
      ],
      "metadata": {
        "id": "OyB7Z1BewKMg"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "org_array=np.array([3,1,9,5])\n",
        "sort_indices_desc=np.argsort(org_array)[::-1]\n",
        "print('행렬 내림차순 정렬 시 원본 행렬의 인덱스:',sort_indices_desc)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ntwPv5Grv6Zf",
        "outputId": "a16cc4fc-b553-43aa-ee6d-1f4db2a19eb7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "행렬 내림차순 정렬 시 원본 행렬의 인덱스: [2 3 0 1]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\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"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hbXU4WLqwLj1",
        "outputId": "e3cd294d-9d10-4527-d308-7f789f496b0f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "성적 오름차순 정렬시 score_array의 인덱스: [0 2 4 1 3]\n",
            "성적 오름차순으로 name_array의 이름 출력: ['John' 'Sarah' 'Samuel' 'Mike' 'Kate']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "선형대수 연산 - 행렬 내적과 전치 행렬 구하기\n",
        "\n",
        "1. 행렬 내적(행렬 곱)\n",
        "\n",
        "np.dot()을 이용해 계산"
      ],
      "metadata": {
        "id": "0oDTNMwzxnj8"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "A=np.array([[1,2,3],[4,5,6]])\n",
        "B=np.array([[7,8],[9,10],[11,12]])\n",
        "dot_product=np.dot(A,B)\n",
        "print('행렬 내적 결과:\\n', dot_product)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TvadljGewLl0",
        "outputId": "9c01c2fb-ef32-40ba-85e3-dfc262f03d7e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "행렬 내적 결과:\n",
            " [[ 58  64]\n",
            " [139 154]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "2. 전치 행렬\n",
        "\n",
        "transpose()를 이용"
      ],
      "metadata": {
        "id": "mJwgX5xXyTbm"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "A=np.array([[1,2],[3,4]])\n",
        "transpose_mat=np.transpose(A)\n",
        "print('A의 전치 행렬:\\n', transpose_mat)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CYDwsmWcwLoI",
        "outputId": "3a1e6094-bde1-477b-d240-9adaedf0eae2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "A의 전치 행렬:\n",
            " [[1 3]\n",
            " [2 4]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "BdJBQ7QJwLqh"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "x2YxJNU_wLtC"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "61rFddLJwLvP"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "-C74ZxcpwLxj"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "zZGD-iq1wL1C"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}