Numpy_Notebook.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "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.6.4"
    },
    "colab": {
      "name": "03_Numpy_Notebook.ipynb",
      "provenance": []
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qxCbKUtOzxGr",
        "colab_type": "text"
      },
      "source": [
        "## 建立一維numpy array"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_CK2ZmVWzxGt",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "5a3589e4-6196-4467-f094-6ec1f0798db8"
      },
      "source": [
        "import numpy as np\n",
        "\n",
        "an_array = np.array([3, 33, 333])  # Create a rank 1 array\n",
        "\n",
        "print(type(an_array))              # The type of an ndarray is: \"<class 'numpy.ndarray'>\""
      ],
      "execution_count": 77,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "<class 'numpy.ndarray'>\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jhkSik8UzxGz",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "e860459b-fe97-4a07-ea4f-80391f7b02df"
      },
      "source": [
        "# test the shape of the array we just created, it should have just one dimension (Rank 1)\n",
        "print(an_array.shape)"
      ],
      "execution_count": 78,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "(3,)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "P_DvTCuAzxG3",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "8f5ad88d-c810-486f-86d2-826617bd8b1d"
      },
      "source": [
        "# because this is a 1-rank array, we need only one index to accesss each element\n",
        "print(an_array[0], an_array[1], an_array[2]) "
      ],
      "execution_count": 79,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "3 33 333\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LY-skAdHzxG7",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "217b153a-aadb-419c-c224-119a56096707"
      },
      "source": [
        "an_array[0] =888            # ndarrays are mutable, here we change an element of the array\n",
        "\n",
        "print(an_array)"
      ],
      "execution_count": 80,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[888  33 333]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "D04FfGwO2Ol2",
        "colab_type": "text"
      },
      "source": [
        "## 建立二維 numpy array，格式[[row],[row]]"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aBEnQdTWzxHA",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 84
        },
        "outputId": "e86c68b3-455a-42f8-e97f-f800a6c5d44c"
      },
      "source": [
        "another = np.array([[11,12,13],[21,22,23]])   # Create a rank 2 array\n",
        "\n",
        "print(another)  # print the array\n",
        "\n",
        "print(\"The shape is 2 rows, 3 columns: \", another.shape)  # rows x columns                   \n",
        "\n",
        "print(\"Accessing elements [0,0], [0,1], and [1,0] of the ndarray: \", another[0, 0], \", \",another[0, 1],\", \", another[1, 0])"
      ],
      "execution_count": 81,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[11 12 13]\n",
            " [21 22 23]]\n",
            "The shape is 2 rows, 3 columns:  (2, 3)\n",
            "Accessing elements [0,0], [0,1], and [1,0] of the ndarray:  11 ,  12 ,  21\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cjt_8nxTzxHF",
        "colab_type": "text"
      },
      "source": [
        "## 我們創建了許多具有不同形狀和不同預設值不同大小的array。 numpy有許多內建方法"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "70d6HKlczxHH",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 50
        },
        "outputId": "02b086fa-1c0b-4667-859e-9d217f0acc16"
      },
      "source": [
        "import numpy as np\n",
        "\n",
        "# create a 2x2 array of zeros\n",
        "ex1 = np.zeros((2,2))      \n",
        "print(ex1)                              "
      ],
      "execution_count": 82,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[0. 0.]\n",
            " [0. 0.]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "F7FrD2QdzxHL",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 50
        },
        "outputId": "3b64035f-cb31-4382-a39b-d0a02e1388ae"
      },
      "source": [
        "# create a 2x2 array filled with 9.0\n",
        "ex2 = np.full((2,2), 9.0)  \n",
        "print(ex2)   "
      ],
      "execution_count": 83,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[9. 9.]\n",
            " [9. 9.]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uytJhMIazxHO",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 50
        },
        "outputId": "507e19bb-6a29-48ef-9745-2a5dabd7306c"
      },
      "source": [
        "# create a 2x2 matrix with the diagonal 1s and the others 0\n",
        "ex3 = np.eye(2,2)\n",
        "print(ex3)  "
      ],
      "execution_count": 84,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[1. 0.]\n",
            " [0. 1.]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jRlVA4EqzxHS",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "c9483d2b-4923-4400-c780-87bb6a146cfc"
      },
      "source": [
        "# create an array of ones\n",
        "ex4 = np.ones((1,2))\n",
        "print(ex4)    "
      ],
      "execution_count": 85,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[1. 1.]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TOdWEF3lzxHW",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 67
        },
        "outputId": "699f9099-94bb-45a1-84a5-bd4691d10181"
      },
      "source": [
        "# notice that the above ndarray (ex4) is actually rank 2, it is a 2x1 array\n",
        "print(ex4.shape)\n",
        "\n",
        "# which means we need to use two indexes to access an element\n",
        "print()\n",
        "print(ex4[0,1])"
      ],
      "execution_count": 86,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "(1, 2)\n",
            "\n",
            "1.0\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vsaSt8fGzxHa",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 50
        },
        "outputId": "bebee657-270a-4242-a3ba-653e967d40df"
      },
      "source": [
        "# create an array of random floats between 0 and 1\n",
        "ex5 = np.random.random((2,2))\n",
        "print(ex5)    "
      ],
      "execution_count": 87,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[0.40070776 0.10819289]\n",
            " [0.32429497 0.6067298 ]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Xy8UEMRBzxHd",
        "colab_type": "text"
      },
      "source": [
        "<p style=\"font-family: Arial; font-size:2.75em;color:purple; font-style:bold\"><br>\n",
        "\n",
        "Array Indexing\n",
        "<br><br></p>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QMXDtxTlzxHf",
        "colab_type": "text"
      },
      "source": [
        "<p style=\"font-family: Arial; font-size:1.75em;color:#2462C0; font-style:bold\"><br>\n",
        "Slice indexing:\n",
        "</p>\n",
        "\n",
        "Similar to the use of slice indexing with lists and strings, we can use slice indexing to pull out sub-regions of ndarrays."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CSXc8KBLzxHg",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 67
        },
        "outputId": "2f59c2b3-00d6-434c-e6ad-f3ed14e333e8"
      },
      "source": [
        "import numpy as np\n",
        "\n",
        "# Rank 2 array of shape (3, 4)\n",
        "an_array = np.array([[11,12,13,14], [21,22,23,24], [31,32,33,34]])\n",
        "print(an_array)"
      ],
      "execution_count": 88,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[11 12 13 14]\n",
            " [21 22 23 24]\n",
            " [31 32 33 34]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9OZajXEmzxHj",
        "colab_type": "text"
      },
      "source": [
        "Use array slicing to get a subarray consisting of the first 2 rows x 2 columns."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "E-AYH_1LzxHl",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 50
        },
        "outputId": "d5a06408-55ed-43ae-b01a-5a255fc1d600"
      },
      "source": [
        "a_slice = an_array[:2, 1:3]\n",
        "print(a_slice)"
      ],
      "execution_count": 89,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[12 13]\n",
            " [22 23]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iJ1ijT5nzxHq",
        "colab_type": "text"
      },
      "source": [
        "When you modify a slice, you actually modify the underlying array."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gzzPZuKxzxHr",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 50
        },
        "outputId": "937b3bc4-b459-415f-ac4e-3e592986d2ab"
      },
      "source": [
        "print(\"Before:\", an_array[0, 1])   #inspect the element at 0, 1  \n",
        "a_slice[0, 0] = 1000    # a_slice[0, 0] is the same piece of data as an_array[0, 1]\n",
        "print(\"After:\", an_array[0, 1])    "
      ],
      "execution_count": 90,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Before: 12\n",
            "After: 1000\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pGfF8WPLzxHw",
        "colab_type": "text"
      },
      "source": [
        "<p style=\"font-family: Arial; font-size:1.75em;color:#2462C0; font-style:bold\"><br>\n",
        "\n",
        "Use both integer indexing & slice indexing\n",
        "</p>\n",
        "\n",
        "We can use combinations of integer indexing and slice indexing to create different shaped matrices."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UTA-rdFHzxHx",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 67
        },
        "outputId": "75e259f2-e08b-4bfe-9850-1ae94939cc77"
      },
      "source": [
        "# Create a Rank 2 array of shape (3, 4)\n",
        "an_array = np.array([[11,12,13,14], [21,22,23,24], [31,32,33,34]])\n",
        "print(an_array)"
      ],
      "execution_count": 91,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[11 12 13 14]\n",
            " [21 22 23 24]\n",
            " [31 32 33 34]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gOdGVSfDzxH5",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "f40f9595-320f-4412-b3d7-255e6a3c36e0"
      },
      "source": [
        "# Using both integer indexing & slicing generates an array of lower rank\n",
        "row_rank1 = an_array[1, :]    # Rank 1 view \n",
        "print(row_rank1, row_rank1.shape)  # notice only a single []"
      ],
      "execution_count": 92,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[21 22 23 24] (4,)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DDAyUN3hzxH8",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "694ef29a-a754-4572-8a12-272a2ae80c5a"
      },
      "source": [
        "# Slicing alone: generates an array of the same rank as the an_array\n",
        "row_rank2 = an_array[1:2, :]  # Rank 2 view \n",
        "\n",
        "print(row_rank2, row_rank2.shape)   # Notice the [[ ]]"
      ],
      "execution_count": 93,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[21 22 23 24]] (1, 4)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "M-RHhSggzxIA",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 118
        },
        "outputId": "b3180f36-a777-4718-b953-9a85cb4bd24a"
      },
      "source": [
        "#We can do the same thing for columns of an array:\n",
        "\n",
        "print()\n",
        "col_rank1 = an_array[:, 1]\n",
        "col_rank2 = an_array[:, 1:2]\n",
        "\n",
        "print(col_rank1, col_rank1.shape)  # Rank 1\n",
        "print()\n",
        "print(col_rank2, col_rank2.shape)  # Rank 2"
      ],
      "execution_count": 94,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\n",
            "[12 22 32] (3,)\n",
            "\n",
            "[[12]\n",
            " [22]\n",
            " [32]] (3, 1)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "roEU7jITzxID",
        "colab_type": "text"
      },
      "source": [
        "<p style=\"font-family: Arial; font-size:1.75em;color:#2462C0; font-style:bold\"><br>\n",
        "\n",
        "Array Indexing for changing elements:\n",
        "</p>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "10Youw0uzxIE",
        "colab_type": "text"
      },
      "source": [
        "Sometimes it's useful to use an array of indexes to access or change elements."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "E12-HpvizxIF",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 101
        },
        "outputId": "131ced19-6987-4e73-89d7-cbd225fe3026"
      },
      "source": [
        "# Create a new array\n",
        "an_array = np.array([[11,12,13], [21,22,23], [31,32,33], [41,42,43]])\n",
        "\n",
        "print('Original Array:')\n",
        "print(an_array)"
      ],
      "execution_count": 95,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Original Array:\n",
            "[[11 12 13]\n",
            " [21 22 23]\n",
            " [31 32 33]\n",
            " [41 42 43]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1jWbQm0dzxIJ",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 84
        },
        "outputId": "01af86ef-069d-44fe-dc21-415eccb106c6"
      },
      "source": [
        "# Create an array of indices\n",
        "col_indices = np.array([0, 1, 2, 0])\n",
        "print('\\nCol indices picked : ', col_indices)\n",
        "\n",
        "row_indices = np.arange(4)\n",
        "print('\\nRows indices picked : ', row_indices)"
      ],
      "execution_count": 96,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Col indices picked :  [0 1 2 0]\n",
            "\n",
            "Rows indices picked :  [0 1 2 3]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "r70kMfNfzxIM",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 84
        },
        "outputId": "e5f9a9fb-a099-4937-9a1b-6c2d1b2e7b94"
      },
      "source": [
        "# Examine the pairings of row_indices and col_indices.  These are the elements we'll change next.\n",
        "for row,col in zip(row_indices,col_indices):\n",
        "    print(row, \", \",col)"
      ],
      "execution_count": 97,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0 ,  0\n",
            "1 ,  1\n",
            "2 ,  2\n",
            "3 ,  0\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OeGS-DUPzxIP",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "e310719e-7b9f-4b5e-d46f-3a1a9f6d2adc"
      },
      "source": [
        "# Select one element from each row\n",
        "print('Values in the array at those indices: ',an_array[row_indices, col_indices])"
      ],
      "execution_count": 98,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Values in the array at those indices:  [11 22 33 41]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cZMNDTl6zxIT",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 118
        },
        "outputId": "78781c6f-e9c9-476f-e242-35aaf1a852ea"
      },
      "source": [
        "# Change one element from each row using the indices selected\n",
        "an_array[row_indices, col_indices] += 100000\n",
        "\n",
        "print('\\nChanged Array:')\n",
        "print(an_array)"
      ],
      "execution_count": 99,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "\n",
            "Changed Array:\n",
            "[[100011     12     13]\n",
            " [    21 100022     23]\n",
            " [    31     32 100033]\n",
            " [100041     42     43]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "L9OtFs89zxIW",
        "colab_type": "text"
      },
      "source": [
        "<p style=\"font-family: Arial; font-size:2.75em;color:purple; font-style:bold\"><br>\n",
        "Boolean Indexing\n",
        "\n",
        "<br><br></p>\n",
        "<p style=\"font-family: Arial; font-size:1.75em;color:#2462C0; font-style:bold\"><br>\n",
        "\n",
        "Array Indexing for changing elements:\n",
        "</p>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "J2ygPPT5zxIX",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 67
        },
        "outputId": "6bf8a514-20ac-4f98-ad84-9c5c8a65e099"
      },
      "source": [
        "# create a 3x2 array\n",
        "an_array = np.array([[11,12], [21, 22], [31, 32]])\n",
        "print(an_array)"
      ],
      "execution_count": 100,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[11 12]\n",
            " [21 22]\n",
            " [31 32]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yxcgTj3CzxIb",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 67
        },
        "outputId": "52675e91-cc32-44d6-d808-2080d60f45c6"
      },
      "source": [
        "# create a filter which will be boolean values for whether each element meets this condition\n",
        "filter = (an_array > 15)\n",
        "filter"
      ],
      "execution_count": 101,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[False, False],\n",
              "       [ True,  True],\n",
              "       [ True,  True]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 101
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Knv-tEHEzxIf",
        "colab_type": "text"
      },
      "source": [
        "Notice that the filter is a same size ndarray as an_array which is filled with True for each element whose corresponding element in an_array which is greater than 15 and False for those elements whose value is less than 15."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "L5J9tvCvzxIh",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "da9ec711-2722-466b-9081-9a727fc132f7"
      },
      "source": [
        "# we can now select just those elements which meet that criteria\n",
        "print(an_array[filter])"
      ],
      "execution_count": 102,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[21 22 31 32]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jMXm40PyzxIm",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "d366793b-2334-40dd-edd4-818768dc4e1a"
      },
      "source": [
        "# For short, we could have just used the approach below without the need for the separate filter array.\n",
        "\n",
        "an_array[(an_array % 2 == 0)]"
      ],
      "execution_count": 103,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([12, 22, 32])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 103
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QBwpkSWHzxIq",
        "colab_type": "text"
      },
      "source": [
        "What is particularly useful is that we can actually change elements in the array applying a similar logical filter.  Let's add 100 to all the even values."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "L2KmMZUozxIs",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 67
        },
        "outputId": "84cc36a9-fb12-481c-d102-a6902503d7d5"
      },
      "source": [
        "an_array[an_array % 2 == 0] +=100\n",
        "print(an_array)"
      ],
      "execution_count": 104,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[ 11 112]\n",
            " [ 21 122]\n",
            " [ 31 132]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kcV7PUXrzxIv",
        "colab_type": "text"
      },
      "source": [
        "<p style=\"font-family: Arial; font-size:2.75em;color:purple; font-style:bold\"><br>\n",
        "\n",
        "Datatypes and Array Operations\n",
        "<br><br></p>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xJZZfpPHzxIw",
        "colab_type": "text"
      },
      "source": [
        "<p style=\"font-family: Arial; font-size:1.75em;color:#2462C0; font-style:bold\"><br>\n",
        "\n",
        "Datatypes:\n",
        "</p>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Q-BbQhBzzxIx",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "50c6dd1e-1a4d-40c3-e8b9-769a94646795"
      },
      "source": [
        "ex1 = np.array([11, 12]) # Python assigns the  data type\n",
        "print(ex1.dtype)"
      ],
      "execution_count": 105,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "int64\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "v8xjjukhzxI0",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "6f5369fd-b31f-4e6e-f6a2-08b93e8b6fb3"
      },
      "source": [
        "ex2 = np.array([11.0, 12.0]) # Python assigns the  data type\n",
        "print(ex2.dtype)"
      ],
      "execution_count": 106,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "float64\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VttMo_Q7zxI3",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "51c89e12-5270-4a70-f65d-df038bc74fa9"
      },
      "source": [
        "ex3 = np.array([11, 21], dtype=np.int64) #You can also tell Python the  data type\n",
        "print(ex3.dtype)"
      ],
      "execution_count": 107,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "int64\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3BWVK-Z8zxI7",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 67
        },
        "outputId": "c8dc8246-356d-43f9-9820-b2381ecdc8ac"
      },
      "source": [
        "# you can use this to force floats into integers (using floor function)\n",
        "ex4 = np.array([11.1,12.7], dtype=np.int64)\n",
        "print(ex4.dtype)\n",
        "print()\n",
        "print(ex4)"
      ],
      "execution_count": 108,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "int64\n",
            "\n",
            "[11 12]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xxaJRShvzxJB",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 67
        },
        "outputId": "4feaabae-7cfa-4e6e-8d17-713c692ac597"
      },
      "source": [
        "# you can use this to force integers into floats if you anticipate\n",
        "# the values may change to floats later\n",
        "ex5 = np.array([11, 21], dtype=np.float64)\n",
        "print(ex5.dtype)\n",
        "print()\n",
        "print(ex5)"
      ],
      "execution_count": 109,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "float64\n",
            "\n",
            "[11. 21.]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "G3sGyzaUzxJE",
        "colab_type": "text"
      },
      "source": [
        "<p style=\"font-family: Arial; font-size:1.75em;color:#2462C0; font-style:bold\"><br>\n",
        "\n",
        "Arithmetic Array Operations:\n",
        "\n",
        "</p>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Q_lrdMVVzxJF",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 101
        },
        "outputId": "adf4aae7-535e-4eae-bbb7-999ea634a295"
      },
      "source": [
        "x = np.array([[111,112],[121,122]], dtype=np.int)\n",
        "y = np.array([[211.1,212.1],[221.1,222.1]], dtype=np.float64)\n",
        "\n",
        "print(x)\n",
        "print()\n",
        "print(y)"
      ],
      "execution_count": 110,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[111 112]\n",
            " [121 122]]\n",
            "\n",
            "[[211.1 212.1]\n",
            " [221.1 222.1]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wKbiBF3fzxJH",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 101
        },
        "outputId": "257c5f75-4069-476a-8cee-7d842d39fc61"
      },
      "source": [
        "# add\n",
        "print(x + y)         # The plus sign works\n",
        "print()\n",
        "print(np.add(x, y))  # so does the numpy function \"add\""
      ],
      "execution_count": 111,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[322.1 324.1]\n",
            " [342.1 344.1]]\n",
            "\n",
            "[[322.1 324.1]\n",
            " [342.1 344.1]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XH7kBpQ-zxJO",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 101
        },
        "outputId": "3543267a-25a2-4683-ca28-0f5906acaad9"
      },
      "source": [
        "# subtract\n",
        "print(x - y)\n",
        "print()\n",
        "print(np.subtract(x, y))"
      ],
      "execution_count": 112,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[-100.1 -100.1]\n",
            " [-100.1 -100.1]]\n",
            "\n",
            "[[-100.1 -100.1]\n",
            " [-100.1 -100.1]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jgASms80zxJX",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 101
        },
        "outputId": "3c291149-21a1-4f88-cfd3-b3478cd0e543"
      },
      "source": [
        "# multiply\n",
        "print(x * y)\n",
        "print()\n",
        "print(np.multiply(x, y))"
      ],
      "execution_count": 113,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[23432.1 23755.2]\n",
            " [26753.1 27096.2]]\n",
            "\n",
            "[[23432.1 23755.2]\n",
            " [26753.1 27096.2]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6P-N79C5zxJb",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 101
        },
        "outputId": "7e94d6b5-ff51-414d-fa40-7340f7561a22"
      },
      "source": [
        "# divide\n",
        "print(x / y)\n",
        "print()\n",
        "print(np.divide(x, y))"
      ],
      "execution_count": 114,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[0.52581715 0.52805281]\n",
            " [0.54726368 0.54930212]]\n",
            "\n",
            "[[0.52581715 0.52805281]\n",
            " [0.54726368 0.54930212]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hIqN7W6KzxJe",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 50
        },
        "outputId": "5dbb43f5-ab35-46d6-afd1-d7c32fc857aa"
      },
      "source": [
        "# square root\n",
        "print(np.sqrt(x))"
      ],
      "execution_count": 115,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[10.53565375 10.58300524]\n",
            " [11.         11.04536102]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "06-di_lczxJi",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 50
        },
        "outputId": "d89aaff4-ce20-47f9-e27d-d92bc4b96cfb"
      },
      "source": [
        "# exponent (e ** x)\n",
        "print(np.exp(x))"
      ],
      "execution_count": 116,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[1.60948707e+48 4.37503945e+48]\n",
            " [3.54513118e+52 9.63666567e+52]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PXVWpO46zxJo",
        "colab_type": "text"
      },
      "source": [
        "<p style=\"font-family: Arial; font-size:2.75em;color:purple; font-style:bold\"><br>\n",
        "\n",
        "Statistical Methods, Sorting, and <br> <br> Set Operations:\n",
        "<br><br>\n",
        "</p>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "otMuiHNxzxJp",
        "colab_type": "text"
      },
      "source": [
        "<p style=\"font-family: Arial; font-size:1.75em;color:#2462C0; font-style:bold\"><br>\n",
        "\n",
        "Basic Statistical Operations:\n",
        "</p>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ayhnUCMuzxJp",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 50
        },
        "outputId": "1582adb9-4f01-43c8-8cdc-8f2f10a22620"
      },
      "source": [
        "# setup a random 2 x 4 matrix\n",
        "arr = 10 * np.random.randn(2,5)\n",
        "print(arr)"
      ],
      "execution_count": 117,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[ 0.75534466 -3.86190488  8.27931592 -6.71578027 17.1384893 ]\n",
            " [-6.4418831   4.24197803  8.68985157  8.17719663 11.70194147]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pYTRVmTXzxJu",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "66475231-7f6b-4ac5-c905-566b20a72e70"
      },
      "source": [
        "# compute the mean for all elements\n",
        "print(arr.mean())"
      ],
      "execution_count": 118,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "4.196454933939177\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Qc4DV-ttzxJz",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "c0c79ce9-0e9b-4a4f-a007-638c5a6f707a"
      },
      "source": [
        "# compute the means by row\n",
        "print(arr.mean(axis = 1))"
      ],
      "execution_count": 119,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[3.11909295 5.27381692]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "URVyKqT-zxJ2",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "9c563917-42a1-4b47-88d8-3ae5cb10af00"
      },
      "source": [
        "# compute the means by column\n",
        "print(arr.mean(axis = 0))"
      ],
      "execution_count": 120,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[-2.84326922  0.19003657  8.48458374  0.73070818 14.42021539]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yqnM6fNizxJ4",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "2efc636d-b89a-487f-f312-4730c562857b"
      },
      "source": [
        "# sum all the elements\n",
        "print(arr.sum())"
      ],
      "execution_count": 121,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "41.964549339391766\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "T0sSksrDzxJ9",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "e4b437f1-35fb-4c7b-a4d9-ff3046b76355"
      },
      "source": [
        "# compute the medians\n",
        "print(np.median(arr, axis = 1))"
      ],
      "execution_count": 122,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[0.75534466 8.17719663]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "p6UY6EwVzxKC",
        "colab_type": "text"
      },
      "source": [
        "<p style=\"font-family: Arial; font-size:1.75em;color:#2462C0; font-style:bold\"><br>\n",
        "\n",
        "Sorting:\n",
        "</p>\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "L4-iDw3yzxKD",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 50
        },
        "outputId": "be0e609f-cd12-49f4-e334-c9ca15ae582c"
      },
      "source": [
        "# create a 10 element array of randoms\n",
        "unsorted = np.random.randn(10)\n",
        "\n",
        "print(unsorted)"
      ],
      "execution_count": 123,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[-0.93473651 -0.42581582  1.78342195  0.80526206 -0.89678488  0.33589644\n",
            "  0.51664589  0.21404145 -0.59935301  0.94215139]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pC_GIx2izxKF",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 101
        },
        "outputId": "fe1e6da7-f9b4-458a-e93e-73b31262b923"
      },
      "source": [
        "# create copy and sort\n",
        "sorted = np.array(unsorted)\n",
        "sorted.sort()\n",
        "\n",
        "print(sorted)\n",
        "print()\n",
        "print(unsorted)"
      ],
      "execution_count": 124,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[-0.93473651 -0.89678488 -0.59935301 -0.42581582  0.21404145  0.33589644\n",
            "  0.51664589  0.80526206  0.94215139  1.78342195]\n",
            "\n",
            "[-0.93473651 -0.42581582  1.78342195  0.80526206 -0.89678488  0.33589644\n",
            "  0.51664589  0.21404145 -0.59935301  0.94215139]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-9jkDKNlzxKH",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 50
        },
        "outputId": "08a95c93-e75f-488c-b49a-5735c56d852f"
      },
      "source": [
        "# inplace sorting\n",
        "unsorted.sort() \n",
        "\n",
        "print(unsorted)"
      ],
      "execution_count": 125,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[-0.93473651 -0.89678488 -0.59935301 -0.42581582  0.21404145  0.33589644\n",
            "  0.51664589  0.80526206  0.94215139  1.78342195]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5UT9i30jzxKJ",
        "colab_type": "text"
      },
      "source": [
        "<p style=\"font-family: Arial; font-size:1.75em;color:#2462C0; font-style:bold\"><br>\n",
        "\n",
        "Finding Unique elements:\n",
        "</p>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oqicT0yrzxKL",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "5e9f2103-29b7-4939-a299-99a957ee8ac5"
      },
      "source": [
        "array = np.array([1,2,1,4,2,1,4,2])\n",
        "\n",
        "print(np.unique(array))"
      ],
      "execution_count": 126,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[1 2 4]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OpeR1FWQzxKN",
        "colab_type": "text"
      },
      "source": [
        "<p style=\"font-family: Arial; font-size:1.75em;color:#2462C0; font-style:bold\"><br>\n",
        "\n",
        "Set Operations with np.array data type:\n",
        "</p>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ttiMEDKazxKN",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "b50525ba-193c-4d30-dbcc-ae7b6080f396"
      },
      "source": [
        "s1 = np.array(['desk','chair','bulb'])\n",
        "s2 = np.array(['lamp','bulb','chair'])\n",
        "print(s1, s2)"
      ],
      "execution_count": 127,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['desk' 'chair' 'bulb'] ['lamp' 'bulb' 'chair']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "I3xmG4Th8Mue",
        "colab_type": "text"
      },
      "source": [
        "## 交集"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8Viv3_tWzxKP",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "1a9d313d-43b0-4989-e0a2-ef8b5639c16d"
      },
      "source": [
        "print( np.intersect1d(s1, s2) ) "
      ],
      "execution_count": 128,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['bulb' 'chair']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ClFnRkoH8W21",
        "colab_type": "text"
      },
      "source": [
        "## 組成一個一維且不重複"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AsbUkEK1zxKS",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "62a525a2-2ad8-44be-c2f5-2a1aca280f2b"
      },
      "source": [
        "print( np.union1d(s1, s2) )"
      ],
      "execution_count": 129,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['bulb' 'chair' 'desk' 'lamp']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tHXfT6PAzxKW",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "cb6718c5-517e-4072-b241-494a64c89ea1"
      },
      "source": [
        "print( np.setdiff1d(s1, s2) )# elements in s1 that are not in s2"
      ],
      "execution_count": 130,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['desk']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gk8LzCU0zxKb",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "db843bef-03df-4bfc-8ed0-31cfb3351358"
      },
      "source": [
        "print( np.in1d(s1, s2) )#which element of s1 is also in s2"
      ],
      "execution_count": 131,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[False  True  True]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sngHh35FzxKd",
        "colab_type": "text"
      },
      "source": [
        "<p style=\"font-family: Arial; font-size:2.75em;color:purple; font-style:bold\"><br>\n",
        "\n",
        "Broadcasting:\n",
        "<br><br>\n",
        "</p>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KqEq7s_JzxKe",
        "colab_type": "text"
      },
      "source": [
        "Introduction to broadcasting. <br>\n",
        "For more details, please see: <br>\n",
        "https://docs.scipy.org/doc/numpy-1.10.1/user/basics.broadcasting.html"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uurnawSjzxKf",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 84
        },
        "outputId": "3fd8af02-c155-4ed9-feca-79f64384774c"
      },
      "source": [
        "import numpy as np\n",
        "\n",
        "start = np.zeros((4,3))\n",
        "print(start)"
      ],
      "execution_count": 132,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[0. 0. 0.]\n",
            " [0. 0. 0.]\n",
            " [0. 0. 0.]\n",
            " [0. 0. 0.]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bngU1gJTzxKi",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "3dcde3ef-688f-4d99-96ab-da1ad539babe"
      },
      "source": [
        "# create a rank 1 ndarray with 3 values\n",
        "add_rows = np.array([1, 0, 2])\n",
        "print(add_rows)"
      ],
      "execution_count": 133,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[1 0 2]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "97siOcZWzxKk",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 84
        },
        "outputId": "afdbab5e-ddae-40bb-b607-7add6088f592"
      },
      "source": [
        "y = start + add_rows  # add to each row of 'start' using broadcasting\n",
        "print(y)"
      ],
      "execution_count": 134,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[1. 0. 2.]\n",
            " [1. 0. 2.]\n",
            " [1. 0. 2.]\n",
            " [1. 0. 2.]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jXJKQLsxzxKn",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 84
        },
        "outputId": "162338c3-7da8-4a7f-9dd1-f75ce9be233c"
      },
      "source": [
        "# create an ndarray which is 4 x 1 to broadcast across columns\n",
        "add_cols = np.array([[0,1,2,3]])\n",
        "add_cols = add_cols.T\n",
        "\n",
        "print(add_cols)"
      ],
      "execution_count": 135,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[0]\n",
            " [1]\n",
            " [2]\n",
            " [3]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JUJVTvzPzxKt",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 84
        },
        "outputId": "19023f78-f804-4f4d-c051-33df07a38dc8"
      },
      "source": [
        "# add to each column of 'start' using broadcasting\n",
        "y = start + add_cols \n",
        "print(y)"
      ],
      "execution_count": 136,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[0. 0. 0.]\n",
            " [1. 1. 1.]\n",
            " [2. 2. 2.]\n",
            " [3. 3. 3.]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "frnAWjoKzxKy",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 84
        },
        "outputId": "2a580bd9-bbf9-44dc-d8e6-2dc80e055685"
      },
      "source": [
        "# this will just broadcast in both dimensions\n",
        "add_scalar = np.array([1])  \n",
        "print(start+add_scalar)"
      ],
      "execution_count": 137,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[1. 1. 1.]\n",
            " [1. 1. 1.]\n",
            " [1. 1. 1.]\n",
            " [1. 1. 1.]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ynR8Q7KqzxK2",
        "colab_type": "text"
      },
      "source": [
        "Example from the slides:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jEuqq1VFzxK3",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 67
        },
        "outputId": "6d4c9be3-f40c-42bd-83d7-d389a4649554"
      },
      "source": [
        "# create our 3x4 matrix\n",
        "arrA = np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12]])\n",
        "print(arrA)"
      ],
      "execution_count": 138,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[ 1  2  3  4]\n",
            " [ 5  6  7  8]\n",
            " [ 9 10 11 12]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zNjQLCYRzxK7",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "f1cee881-d051-4b34-c7f3-c42bfdf75e3e"
      },
      "source": [
        "# create our 4x1 array\n",
        "arrB = [0,1,0,2]\n",
        "print(arrB)"
      ],
      "execution_count": 139,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[0, 1, 0, 2]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HKKGEfB5zxK9",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 67
        },
        "outputId": "11799dca-1cb9-4132-cad2-d21975baf2f4"
      },
      "source": [
        "# add the two together using broadcasting\n",
        "print(arrA + arrB)"
      ],
      "execution_count": 140,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[ 1  3  3  6]\n",
            " [ 5  7  7 10]\n",
            " [ 9 11 11 14]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xP8ONE0czxLA",
        "colab_type": "text"
      },
      "source": [
        "<p style=\"font-family: Arial; font-size:2.75em;color:purple; font-style:bold\"><br>\n",
        "\n",
        "Speedtest: ndarrays vs lists\n",
        "<br><br>\n",
        "</p>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QfNFmL8bzxLB",
        "colab_type": "text"
      },
      "source": [
        "First setup paramaters for the speed test. We'll be testing time to sum elements in an ndarray versus a list."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qexad1PhzxLC",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "from numpy import arange\n",
        "from timeit import Timer\n",
        "\n",
        "size    = 1000000\n",
        "timeits = 1000"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jvyT4_jLzxLF",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "9693cb18-4329-4176-f5dd-2aef38ce7ab7"
      },
      "source": [
        "# create the ndarray with values 0,1,2...,size-1\n",
        "nd_array = arange(size)\n",
        "print( type(nd_array) )"
      ],
      "execution_count": 142,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "<class 'numpy.ndarray'>\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nnmm7XP4zxLJ",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "d2999b57-12d0-435e-8f15-5092769e9491"
      },
      "source": [
        "# timer expects the operation as a parameter, \n",
        "# here we pass nd_array.sum()\n",
        "timer_numpy = Timer(\"nd_array.sum()\", \"from __main__ import nd_array\")\n",
        "\n",
        "print(\"Time taken by numpy ndarray: %f seconds\" % \n",
        "      (timer_numpy.timeit(timeits)/timeits))"
      ],
      "execution_count": 143,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Time taken by numpy ndarray: 0.000924 seconds\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mtHWOgI2zxLL",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "fb78e585-d10f-4926-b8c6-1eddd5e06153"
      },
      "source": [
        "# create the list with values 0,1,2...,size-1\n",
        "a_list = list(range(size))\n",
        "print (type(a_list) )"
      ],
      "execution_count": 144,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "<class 'list'>\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qNlp67y1zxLP",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "b21ebccc-a982-4885-9c06-269592a99402"
      },
      "source": [
        "# timer expects the operation as a parameter, here we pass sum(a_list)\n",
        "timer_list = Timer(\"sum(a_list)\", \"from __main__ import a_list\")\n",
        "\n",
        "print(\"Time taken by list:  %f seconds\" % \n",
        "      (timer_list.timeit(timeits)/timeits))"
      ],
      "execution_count": 145,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Time taken by list:  0.007249 seconds\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lWqrTlKPzxLR",
        "colab_type": "text"
      },
      "source": [
        "<p style=\"font-family: Arial; font-size:2.75em;color:purple; font-style:bold\"><br>\n",
        "\n",
        "Read or Write to Disk:\n",
        "<br><br>\n",
        "</p>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "t1Jd8i8uzxLS",
        "colab_type": "text"
      },
      "source": [
        "<p style=\"font-family: Arial; font-size:1.3em;color:#2462C0; font-style:bold\"><br>\n",
        "\n",
        "Binary Format:</p>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KSnpLLz-zxLT",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "x = np.array([ 23.23, 24.24] )"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TlxRJOUuzxLZ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "np.save('an_array', x)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mlvLDO-2zxLb",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "88a3c59b-3069-44ac-df40-579982f38e6f"
      },
      "source": [
        "np.load('an_array.npy')"
      ],
      "execution_count": 148,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([23.23, 24.24])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 148
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0TatZOIazxLd",
        "colab_type": "text"
      },
      "source": [
        "<p style=\"font-family: Arial; font-size:1.3em;color:#2462C0; font-style:bold\"><br>\n",
        "\n",
        "Text Format:</p>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ySu7uk14zxLe",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "np.savetxt('array.txt', X=x, delimiter=',')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Rwj-y9XwzxLg",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 50
        },
        "outputId": "9932c25f-f1f7-4548-b42d-60c24430768e"
      },
      "source": [
        "!cat array.txt"
      ],
      "execution_count": 150,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "2.323000000000000043e+01\n",
            "2.423999999999999844e+01\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "scrolled": true,
        "id": "ihf1TUWxzxLi",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "d37c7d27-806a-48b1-e9b6-e6c9d1320cef"
      },
      "source": [
        "np.loadtxt('array.txt', delimiter=',')"
      ],
      "execution_count": 151,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([23.23, 24.24])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 151
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8T3hh51LzxLj",
        "colab_type": "text"
      },
      "source": [
        "<p style=\"font-family: Arial; font-size:2.75em;color:purple; font-style:bold\"><br>\n",
        "\n",
        "Additional Common ndarray Operations\n",
        "<br><br></p>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sTg4H2XTzxLk",
        "colab_type": "text"
      },
      "source": [
        "<p style=\"font-family: Arial; font-size:1.75em;color:#2462C0; font-style:bold\"><br>\n",
        "\n",
        "Dot Product on Matrices and Inner Product on Vectors:\n",
        "\n",
        "</p>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-X5d5HMZzxLk",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 101
        },
        "outputId": "79096697-7065-4960-a502-8d180272f5e4"
      },
      "source": [
        "# determine the dot product of two matrices\n",
        "x2d = np.array([[1,1],[1,1]])\n",
        "y2d = np.array([[2,2],[2,2]])\n",
        "\n",
        "print(x2d.dot(y2d))\n",
        "print()\n",
        "print(np.dot(x2d, y2d))"
      ],
      "execution_count": 152,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[4 4]\n",
            " [4 4]]\n",
            "\n",
            "[[4 4]\n",
            " [4 4]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HSNpxG0hzxLm",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 67
        },
        "outputId": "ecb0ed85-19c2-428d-cc48-bfc1a921b083"
      },
      "source": [
        "# determine the inner product of two vectors\n",
        "a1d = np.array([9 , 9 ])\n",
        "b1d = np.array([10, 10])\n",
        "\n",
        "print(a1d.dot(b1d))\n",
        "print()\n",
        "print(np.dot(a1d, b1d))"
      ],
      "execution_count": 153,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "180\n",
            "\n",
            "180\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "azFaxsJwzxLo",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 67
        },
        "outputId": "2c132896-c3e2-4204-d204-66bb8c9af677"
      },
      "source": [
        "# dot produce on an array and vector\n",
        "print(x2d.dot(a1d))\n",
        "print()\n",
        "print(np.dot(x2d, a1d))"
      ],
      "execution_count": 154,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[18 18]\n",
            "\n",
            "[18 18]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xqJT2SskzxLq",
        "colab_type": "text"
      },
      "source": [
        "<p style=\"font-family: Arial; font-size:1.75em;color:#2462C0; font-style:bold\"><br>\n",
        "\n",
        "Sum:\n",
        "</p>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SWLzyPRFzxLr",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "be0cf1d6-dc55-4e69-f4ad-232116fc42a9"
      },
      "source": [
        "# sum elements in the array\n",
        "ex1 = np.array([[11,12],[21,22]])\n",
        "\n",
        "print(np.sum(ex1))          # add all members"
      ],
      "execution_count": 155,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "66\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "84J6HHEAzxLu",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "637ad51c-85e8-4b83-858d-aa3ac916575a"
      },
      "source": [
        "print(np.sum(ex1, axis=0))  # columnwise sum"
      ],
      "execution_count": 156,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[32 34]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2uBo_dVEzxLv",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "1e7d4b8a-2568-4dc1-9123-dc1d0c3c9154"
      },
      "source": [
        "print(np.sum(ex1, axis=1))  # rowwise sum"
      ],
      "execution_count": 157,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[23 43]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ci0JRH5mzxLz",
        "colab_type": "text"
      },
      "source": [
        "<p style=\"font-family: Arial; font-size:1.75em;color:#2462C0; font-style:bold\"><br>\n",
        "\n",
        "Element-wise Functions: </p>\n",
        "\n",
        "For example, let's compare two arrays values to get the maximum of each."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eaymkyrIzxL0",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 50
        },
        "outputId": "679c4b44-0640-4d20-8548-f3d5abe56429"
      },
      "source": [
        "# random array\n",
        "x = np.random.randn(8)\n",
        "x"
      ],
      "execution_count": 158,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([-0.18462059,  1.09666456,  1.0053614 ,  0.51115429,  0.20390448,\n",
              "       -0.24367816, -0.23067788,  0.24632734])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 158
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ygxO0l5QzxL5",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 50
        },
        "outputId": "8cfbda67-3f26-4c21-a494-73fe75456c0a"
      },
      "source": [
        "# another random array\n",
        "y = np.random.randn(8)\n",
        "y"
      ],
      "execution_count": 159,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([-0.84507572,  0.92095961,  0.76912853, -0.10658697,  0.627559  ,\n",
              "        0.65884034, -0.72064895,  1.90083842])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 159
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "l51PG5XnzxL8",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 50
        },
        "outputId": "38474447-b35d-47be-af5d-709aca5445e2"
      },
      "source": [
        "# returns element wise maximum between two arrays\n",
        "\n",
        "np.maximum(x, y)"
      ],
      "execution_count": 160,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([-0.18462059,  1.09666456,  1.0053614 ,  0.51115429,  0.627559  ,\n",
              "        0.65884034, -0.23067788,  1.90083842])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 160
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HncH6f7GzxL_",
        "colab_type": "text"
      },
      "source": [
        "<p style=\"font-family: Arial; font-size:1.75em;color:#2462C0; font-style:bold\"><br>\n",
        "\n",
        "Reshaping array:\n",
        "</p>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YNhx31WXzxL_",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "e8238232-0700-44ee-b158-ac9be8bc5b7f"
      },
      "source": [
        "# grab values from 0 through 19 in an array\n",
        "arr = np.arange(20)\n",
        "print(arr)"
      ],
      "execution_count": 161,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xI_EDif4zxMC",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 84
        },
        "outputId": "eceeae8a-f1e5-40e1-ccb7-8098403e3394"
      },
      "source": [
        "# reshape to be a 4 x 5 matrix\n",
        "arr.reshape(4,5)"
      ],
      "execution_count": 162,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[ 0,  1,  2,  3,  4],\n",
              "       [ 5,  6,  7,  8,  9],\n",
              "       [10, 11, 12, 13, 14],\n",
              "       [15, 16, 17, 18, 19]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 162
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VQQzslKlzxME",
        "colab_type": "text"
      },
      "source": [
        "<p style=\"font-family: Arial; font-size:1.75em;color:#2462C0; font-style:bold\"><br>\n",
        "\n",
        "Transpose:\n",
        "\n",
        "</p>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ObU0O_cUzxMF",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 50
        },
        "outputId": "85745ccd-6df7-4a03-b6ca-5d50cf511667"
      },
      "source": [
        "# transpose\n",
        "ex1 = np.array([[11,12],[21,22]])\n",
        "\n",
        "ex1.T"
      ],
      "execution_count": 163,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[11, 21],\n",
              "       [12, 22]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 163
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dCN7f4APzxMG",
        "colab_type": "text"
      },
      "source": [
        "<p style=\"font-family: Arial; font-size:1.75em;color:#2462C0; font-style:bold\"><br>\n",
        "\n",
        "Indexing using where():</p>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jqoxNVpIzxMH",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "x_1 = np.array([1,2,3,4,5])\n",
        "\n",
        "y_1 = np.array([11,22,33,44,55])\n",
        "\n",
        "filter = np.array([True, False, True, False, True])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MfgWNShwzxMI",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "f39a335b-4002-4e00-e9ba-14c3649648ad"
      },
      "source": [
        "out = np.where(filter, x_1, y_1)\n",
        "print(out)"
      ],
      "execution_count": 165,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[ 1 22  3 44  5]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gB9lQqX4zxMK",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 101
        },
        "outputId": "b5e77cf2-f64b-450c-bdc5-7f86e2408a15"
      },
      "source": [
        "mat = np.random.rand(5,5)\n",
        "mat"
      ],
      "execution_count": 166,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[0.20117729, 0.15826017, 0.04693758, 0.57119491, 0.56242448],\n",
              "       [0.861445  , 0.14802137, 0.47910947, 0.15372358, 0.19142938],\n",
              "       [0.70673719, 0.94018727, 0.45526339, 0.75593144, 0.88110746],\n",
              "       [0.78412749, 0.89765211, 0.79978734, 0.86895437, 0.81920535],\n",
              "       [0.96671007, 0.21303525, 0.81226092, 0.6918934 , 0.13028643]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 166
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HZIOacIazxML",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 101
        },
        "outputId": "a4fe6daa-6336-4dac-af55-0b06e8518b5a"
      },
      "source": [
        "np.where( mat > 0.5, 1000, -1)"
      ],
      "execution_count": 167,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[  -1,   -1,   -1, 1000, 1000],\n",
              "       [1000,   -1,   -1,   -1,   -1],\n",
              "       [1000, 1000,   -1, 1000, 1000],\n",
              "       [1000, 1000, 1000, 1000, 1000],\n",
              "       [1000,   -1, 1000, 1000,   -1]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 167
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9sVOCwDpzxMP",
        "colab_type": "text"
      },
      "source": [
        "<p style=\"font-family: Arial; font-size:1.75em;color:#2462C0; font-style:bold\"><br>\n",
        "\n",
        "\"any\" or \"all\" conditionals:</p>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QiqehOa7zxMQ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "arr_bools = np.array([ True, False, True, True, False ])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zTR20nZ2zxMR",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "49571f61-5b35-455e-c7eb-ef3af2d3dd98"
      },
      "source": [
        "arr_bools.any()"
      ],
      "execution_count": 169,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 169
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "scrolled": true,
        "id": "FtM8eUM-zxMT",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "883762f1-674a-4473-8534-793fe364bdec"
      },
      "source": [
        "arr_bools.all()"
      ],
      "execution_count": 170,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 170
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cvSzWdL4zxMV",
        "colab_type": "text"
      },
      "source": [
        "<p style=\"font-family: Arial; font-size:1.75em;color:#2462C0; font-style:bold\"><br>\n",
        "\n",
        "Random Number Generation:\n",
        "</p>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EJnIzbxkzxMW",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "ddb0eb76-532e-4036-b006-c1eaa3ae8de4"
      },
      "source": [
        "Y = np.random.normal(size = (1,5))[0]\n",
        "print(Y)"
      ],
      "execution_count": 171,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[ 0.66005384  0.24769671 -0.3209211   0.81218027 -0.2860185 ]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NELhUnSfzxMZ",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "1665063f-c9bc-41c9-de43-22d409d371f7"
      },
      "source": [
        "Z = np.random.randint(low=2,high=50,size=4)\n",
        "print(Z)"
      ],
      "execution_count": 172,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[29 37 10 34]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lPX_DEmtzxMd",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "4f4bb318-cab9-49e8-cf5c-c9bee283bb07"
      },
      "source": [
        "np.random.permutation(Z) #return a new ordering of elements in Z"
      ],
      "execution_count": 173,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([29, 37, 10, 34])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 173
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kRjBl_gvzxMf",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "2ab8c1f8-b0ab-4561-9fe1-3935f54d134a"
      },
      "source": [
        "np.random.uniform(size=4) #uniform distribution"
      ],
      "execution_count": 174,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([0.55804297, 0.93084166, 0.2980845 , 0.41490324])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 174
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bWLRseZCzxMi",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "abe575d5-17a2-455e-e247-3622775efbee"
      },
      "source": [
        "np.random.normal(size=4) #normal distribution"
      ],
      "execution_count": 175,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([ 0.15428021,  1.62518035,  0.29045857, -0.74742294])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 175
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lzSAqtl5zxMl",
        "colab_type": "text"
      },
      "source": [
        "<p style=\"font-family: Arial; font-size:1.75em;color:#2462C0; font-style:bold\"><br>\n",
        "\n",
        "Merging data sets:\n",
        "</p>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3chd7EcEzxMm",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 101
        },
        "outputId": "00297deb-f05d-4702-94f7-4759c0223458"
      },
      "source": [
        "K = np.random.randint(low=2,high=50,size=(2,2))\n",
        "print(K)\n",
        "\n",
        "print()\n",
        "M = np.random.randint(low=2,high=50,size=(2,2))\n",
        "print(M)"
      ],
      "execution_count": 176,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[10 27]\n",
            " [ 9 17]]\n",
            "\n",
            "[[ 7 13]\n",
            " [13 42]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vwUNLZguzxMo",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 84
        },
        "outputId": "526a5922-c34b-49a5-afd0-c32156accc34"
      },
      "source": [
        "np.vstack((K,M))"
      ],
      "execution_count": 177,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[10, 27],\n",
              "       [ 9, 17],\n",
              "       [ 7, 13],\n",
              "       [13, 42]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 177
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0_1-4Kd5zxMt",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 50
        },
        "outputId": "7115fbe0-e5f6-4177-838f-8c4a79ff95ab"
      },
      "source": [
        "np.hstack((K,M))"
      ],
      "execution_count": 178,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[10, 27,  7, 13],\n",
              "       [ 9, 17, 13, 42]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 178
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "N6QO7g59zxMx",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 84
        },
        "outputId": "37af842a-97e2-4170-a6f7-30f55788bec8"
      },
      "source": [
        "np.concatenate([K, M], axis = 0)"
      ],
      "execution_count": 179,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[10, 27],\n",
              "       [ 9, 17],\n",
              "       [ 7, 13],\n",
              "       [13, 42]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 179
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FzMgoFzkzxM1",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 50
        },
        "outputId": "2f07270d-2caf-4963-c1c5-a9959fd27084"
      },
      "source": [
        "np.concatenate([K, M.T], axis = 1)"
      ],
      "execution_count": 180,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[10, 27,  7, 13],\n",
              "       [ 9, 17, 13, 42]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 180
        }
      ]
    }
  ]
}