lab-00_python_numpy.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Untitled0.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "code",
      "metadata": {
        "id": "iDlwtLdopFH0",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 251
        },
        "outputId": "ffc89204-8ee5-4bfb-d597-3635a73df139"
      },
      "source": [
        "list1 = [1, 2, 3]\n",
        "\n",
        "print(type(list1))\n",
        "print(list1[0], list1[-1]) #인덱스가 음수일 경우 리스트의 끝에서부터 셈\n",
        "\n",
        "list1[1] = \"str1\"\n",
        "print(list1) #리스트는 자료형이 다른 요소도 저장 가능\n",
        "\n",
        "list2 = range(10)\n",
        "print(list2)\n",
        "print(type(list2)) #range Type출력\n",
        "\n",
        "list2 = list(list2) #List Type으로 변환\n",
        "print(type(list2))\n",
        "print(list2[2:4]) # 인덱스 2에서 4(제외)까지 슬라이싱\n",
        "print(list2[2:]) # 인덱스 2에서 끝까지 슬라이싱\n",
        "print(list2[:2]) # 처음부터 인덱스 2(제외)까지 슬라이싱\n",
        "print(list2[:]) # 전체 리스트 슬라이싱\n",
        "print(list2[::2]) # 2씩 증가하면서 리스트 출력\n",
        "print(list2[:-1]) # 슬라이싱 인덱스는 음수도 가능\n",
        "\n",
        "list2[2:4] = [8, 9] # 슬라이스된 리스트에 새로운 리스트 할당\n",
        "list2[2:5] = [8, 9] # ??\n",
        "print(list2)\n",
        "\n"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "<class 'list'>\n",
            "1 3\n",
            "[1, 'str1', 3]\n",
            "range(0, 10)\n",
            "<class 'range'>\n",
            "<class 'list'>\n",
            "[2, 3]\n",
            "[2, 3, 4, 5, 6, 7, 8, 9]\n",
            "[0, 1]\n",
            "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
            "[0, 2, 4, 6, 8]\n",
            "[0, 1, 2, 3, 4, 5, 6, 7, 8]\n",
            "[0, 1, 8, 9, 5, 6, 7, 8, 9]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mf74FzYwrGOS",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 89
        },
        "outputId": "b794dbe3-2811-4577-aa76-710efa0c9d80"
      },
      "source": [
        "animals = ['cat', 'dog', 'monkey']\n",
        "for animal in animals:\n",
        "    print(animal)\n",
        "\n",
        "nums = [0, 1, 2, 3, 4]\n",
        "squares = []\n",
        "for x in nums:\n",
        "    squares.append(x ** 2)\n",
        "print(squares)\n",
        "\n"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "cat\n",
            "dog\n",
            "monkey\n",
            "[0, 1, 4, 9, 16]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zVITzdyVuuDA",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 71
        },
        "outputId": "199a099b-6eb0-48e3-f331-0c846434bdd0"
      },
      "source": [
        "def sign(x):\n",
        "    if x > 0:\n",
        "        return 'positive'\n",
        "    elif x < 0:\n",
        "        return 'negative'\n",
        "    else:\n",
        "        return 'zero'\n",
        "\n",
        "for x in [-1, 0, 1]:\n",
        "    print(sign(x))\n",
        "# 출력 \"negative\", \"zero\", \"positive\", 한 줄에 하나씩 출력.\n",
        "\n"
      ],
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "negative\n",
            "zero\n",
            "positive\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-k97WRnVuxOM",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 53
        },
        "outputId": "9d1d9aca-6755-4683-ed0c-fafeb4177f7e"
      },
      "source": [
        "def hello(name, loud=False):\n",
        "    if loud:\n",
        "        print ('HELLO, %s!' % name.upper())\n",
        "    else:\n",
        "        print ('Hello, %s' % name)\n",
        "\n",
        "hello('Bob') # 출력 \"Hello, Bob\"\n",
        "hello('Fred', loud=True)  # 출력 \"HELLO, FRED!\"\n",
        "\n"
      ],
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Hello, Bob\n",
            "HELLO, FRED!\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KftLKMCiu2CW",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 125
        },
        "outputId": "6e25adc1-0849-49e2-fb8a-3c356e5e0fff"
      },
      "source": [
        "for x, y, z in zip([1, 2, 3], [4, 5, 6], [7, 8, 9]):\n",
        "    print(x, y, z)\n",
        "for x, y, _ in zip([1, 2, 3], [4, 5, 6], [7, 8, 9]): #???\n",
        "    print(x, y, z)\n",
        "\n"
      ],
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1 4 7\n",
            "2 5 8\n",
            "3 6 9\n",
            "1 4 9\n",
            "2 5 9\n",
            "3 6 9\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZCDY9vrou3Bn",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 143
        },
        "outputId": "8cf0a5c7-2a12-4075-efa4-1047a3bdf1b7"
      },
      "source": [
        "# Packing\n",
        "print(1)  # print함수는 몇개의 인자를 받든지 상관하지 않음\n",
        "print(\"a\")\n",
        "print(\"aa\", \"bb\")\n",
        "\n",
        "######################\n",
        "def func(*args):\n",
        "    print(args)\n",
        "    print(type(args))  # Tuple\n",
        "\n",
        "\n",
        "func(1, 2, 3, 'a')\n",
        "\n",
        "######################\n",
        "\n",
        "def func2(**kwargs):\n",
        "    print(kwargs)\n",
        "    print(type(kwargs))  # Dictionary\n",
        "\n",
        "\n",
        "func2(a=1, b=2, c=3, d='a')\n",
        "\n"
      ],
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1\n",
            "a\n",
            "aa bb\n",
            "(1, 2, 3, 'a')\n",
            "<class 'tuple'>\n",
            "{'a': 1, 'b': 2, 'c': 3, 'd': 'a'}\n",
            "<class 'dict'>\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "abBn8m95vCTR",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 71
        },
        "outputId": "f62037ae-b810-408d-a305-285fdc8df5b7"
      },
      "source": [
        "# Unpacking\n",
        "\n",
        "def printSum(a, b, c):\n",
        "    total = a + b + c\n",
        "    print(total)\n",
        "    return\n",
        "\n",
        "\n",
        "lst = [1, 2, 3]\n",
        "\n",
        "# printSum(lst) #Error\n",
        "printSum(*lst)\n",
        "\n",
        "\n",
        "def print_customer_info(**kwargs):\n",
        "    print(kwargs)\n",
        "\n",
        "\n",
        "print_customer_info(name='lee', age='30')  # {'name': 'lee', 'age': '30'}\n",
        "print_customer_info(name='lee', age='30', address='seoul')  # {'name': 'lee', 'age': '30', 'address': 'seoul'}\n",
        "# print_customer_info('lee', '30') #Error\n",
        "\n"
      ],
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "6\n",
            "{'name': 'lee', 'age': '30'}\n",
            "{'name': 'lee', 'age': '30', 'address': 'seoul'}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xd9eZ4ktvFNB",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "36e0960f-e866-4083-f02a-d9be0de92006"
      },
      "source": [
        "class HelloWorld():\n",
        "    def __init__(self):\n",
        "        pass\n",
        "\n",
        "\n",
        "helloworld = HelloWorld()\n",
        "\n",
        "\n",
        "# helloworld() #Error\n",
        "\n",
        "\n",
        "class HelloWorld():\n",
        "    def __init__(self):\n",
        "        pass\n",
        "\n",
        "    def __call__(self):\n",
        "        print(\"Hello world\")\n",
        "\n",
        "\n",
        "helloworld = HelloWorld()\n",
        "\n",
        "helloworld()  # Hello world\n",
        "\n"
      ],
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Hello world\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IVcOsDXUvItv",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class Module():\n",
        "    def __init__(self):\n",
        "        #Initialize\n",
        "        None\n",
        "    def __call__(self, *input, **kwargs):\n",
        "        ...\n",
        "        result = self.forward(*input, **kwargs)\n",
        "\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AzUH11XivNyQ",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 89
        },
        "outputId": "a56147be-f6c2-446e-a596-fb8a0193709d"
      },
      "source": [
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.nn.functional as F\n",
        "\n",
        "class Net(nn.Module):\n",
        "    def __init__(self):\n",
        "        super(Net, self).__init__()\n",
        "        self.conv1 = nn.Conv2d(1, 6, 3)\n",
        "        self.conv2 = nn.Conv2d(6, 16, 3)\n",
        "    def forward(self, x):\n",
        "        # Max pooling over a (2, 2) window\n",
        "        x = F.max_pool2d(F.relu(self.conv1(x)), (2, 2))\n",
        "        # If the size is a square you can only specify a single number\n",
        "        x = F.max_pool2d(F.relu(self.conv2(x)), 2)\n",
        "        return x\n",
        "\n",
        "net = Net()\n",
        "print(net)\n",
        "\n",
        "#net(inputData)\n",
        "\n"
      ],
      "execution_count": 26,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Net(\n",
            "  (conv1): Conv2d(1, 6, kernel_size=(3, 3), stride=(1, 1))\n",
            "  (conv2): Conv2d(6, 16, kernel_size=(3, 3), stride=(1, 1))\n",
            ")\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MO6D10t4vY3G",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 161
        },
        "outputId": "384fd205-1d24-4fdf-a9fe-72f68f71f6f2"
      },
      "source": [
        "import numpy as np\n",
        "\n",
        "a = np.array([1, 2, 3])  # rank가 1인 배열 생성\n",
        "print(type(a))            # 출력 \"<type 'numpy.ndarray'>\"\n",
        "print(a.shape)            # 출력 \"(3,)\"\n",
        "print(a.ndim)               # 출력 \"1\"\n",
        "print(a[0], a[1], a[2])   # 출력 \"1 2 3\"\n",
        "a[0] = 5                 # 요소를 변경\n",
        "print(a)                  # 출력 \"[5, 2, 3]\"\n",
        "\n",
        "b = np.array([[1,2,3],[4,5,6]])   # rank가 2인 배열 생성\n",
        "print(b.shape)                     # 출력 \"(2, 3)\"\n",
        "print(b.ndim)                     # 출력 \"2\"\n",
        "print(b[0, 0], b[0, 1], b[1, 0])   # 출력 \"1 2 4\"\n",
        "\n"
      ],
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "<class 'numpy.ndarray'>\n",
            "(3,)\n",
            "1\n",
            "1 2 3\n",
            "[5 2 3]\n",
            "(2, 3)\n",
            "2\n",
            "1 2 4\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_1KfMJ7VwA_m",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 179
        },
        "outputId": "6262a8b5-5793-41d5-aa7a-26b9dfcb7ec1"
      },
      "source": [
        "import numpy as np\n",
        "\n",
        "a = np.zeros((2,2))  # 모든 값이 0인 배열 생성\n",
        "print(a)              # 출력 \"[[ 0.  0.]\n",
        "                     #       [ 0.  0.]]\"\n",
        "\n",
        "b = np.ones((1,2))   # 모든 값이 1인 배열 생성\n",
        "print(b)              # 출력 \"[[ 1.  1.]]\"\n",
        "\n",
        "c = np.full((2,2), 7) # 모든 값이 특정 상수인 배열 생성\n",
        "print(c)               # 출력 \"[[ 7.  7.]\n",
        "                      #       [ 7.  7.]]\"\n",
        "\n",
        "d = np.eye(2)        # 2x2 단위행렬 생성\n",
        "print(d)              # 출력 \"[[ 1.  0.]\n",
        "                     #       [ 0.  1.]]\"\n",
        "\n",
        "e = np.random.random((2,2)) # 임의의 값으로 채워진 배열 생성\n",
        "print(e)                     # 임의의 값 출력 \"[[ 0.91940167  0.08143941]\n",
        "                            #                  [ 0.68744134  0.87236687]]\"\n",
        "\n"
      ],
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[0. 0.]\n",
            " [0. 0.]]\n",
            "[[1. 1.]]\n",
            "[[7 7]\n",
            " [7 7]]\n",
            "[[1. 0.]\n",
            " [0. 1.]]\n",
            "[[0.69202986 0.44904431]\n",
            " [0.12725894 0.49162866]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bKGfOd3fwEGQ",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 53
        },
        "outputId": "1234df24-765b-4c00-d4c6-4f0c8f83c702"
      },
      "source": [
        "import numpy as np\n",
        "\n",
        "# [[ 1  2  3  4]\n",
        "#  [ 5  6  7  8]\n",
        "#  [ 9 10 11 12]]\n",
        "a = np.array([[1,2,3,4], [5,6,7,8], [9,10,11,12]])\n",
        "\n",
        "# 슬라이싱을 이용하여 첫 두 행과 1열, 2열로 이루어진 부분배열 생성;\n",
        "# b는 shape가 (2,2)인 배열이 됨:\n",
        "# [[2 3]\n",
        "#  [6 7]]\n",
        "b = a[:2, 1:3]\n",
        "\n",
        "# 슬라이싱된 배열은 원본 배열과 같은 데이터를 참조, 즉 슬라이싱된 배열을 수정하면\n",
        "# 원본 배열 역시 수정됨.\n",
        "print(a[0, 1])   # 출력 \"2\"\n",
        "b[0, 0] = 77    # b[0, 0]은 a[0, 1]과 같은 데이터\n",
        "print(a[0, 1])   # 출력 \"77\"\n",
        "\n"
      ],
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "2\n",
            "77\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wSfsHKbHwG2A",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 53
        },
        "outputId": "562f1cd0-1bec-4460-95f8-10b5bb57b9ef"
      },
      "source": [
        "import numpy as np\n",
        "\n",
        "# [[ 1  2  3  4]\n",
        "#  [ 5  6  7  8]\n",
        "#  [ 9 10 11 12]]\n",
        "a = np.array([[1,2,3,4], [5,6,7,8], [9,10,11,12]])\n",
        "\n",
        "\n",
        "b = np.reshape(a, (2, 6))\n",
        "#b = a.reshape(2, 6) # Equivalent Function\n",
        "\n",
        "# 슬라이싱된 배열은 원본 배열과 같은 데이터를 참조, 즉 슬라이싱된 배열을 수정하면\n",
        "# 원본 배열 역시 수정됨.\n",
        "print(b[0, 0])   # 출력 \"2\"\n",
        "b[0, 0] = 77    # b[0, 0]은 a[0, 0]과 같은 데이터\n",
        "print(a[0, 0])   # 출력 \"77\"\n",
        "\n"
      ],
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1\n",
            "77\n"
          ],
          "name": "stdout"
        }
      ]
    }
  ]
}