NumPy_operations_2.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/itsmpython/python_for_data_analysis/blob/main/NumPy_operations_2.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aBz_Z7ECTzXm"
      },
      "source": [
        "![rmotr](https://user-images.githubusercontent.com/7065401/52071918-bda15380-2562-11e9-828c-7f95297e4a82.png)\n",
        "<hr style=\"margin-bottom: 40px;\">\n",
        "\n",
        "# NumPy exercises\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "bIeu6OtNTzXo",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "485c70fb-1f86-4ddb-8c30-a95283cfe927"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1.26.4\n"
          ]
        }
      ],
      "source": [
        "# Import the numpy package under the name np\n",
        "import numpy as np\n",
        "\n",
        "# Print the numpy version and the configuration\n",
        "print(np.__version__)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4A-9RBObTzXq"
      },
      "source": [
        "![purple-divider](https://user-images.githubusercontent.com/7065401/52071927-c1cd7100-2562-11e9-908a-dde91ba14e59.png)\n",
        "\n",
        "## Array creation"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xFFqBLvRTzXq"
      },
      "source": [
        "### Create a numpy array of size 10, filled with zeros."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "MpfHKPluTzXq",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7911f1d2-6cb5-4d3a-f761-47db428bdae3"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])"
            ]
          },
          "metadata": {},
          "execution_count": 3
        }
      ],
      "source": [
        "# your code goes here\n",
        "np.zeros(10)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cell_type": "solution",
        "id": "FzBhVP35TzXr",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "805456f3-39bb-4e9b-b250-ebf3445cbf44"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])"
            ]
          },
          "metadata": {},
          "execution_count": 4
        }
      ],
      "source": [
        "#np.array([0] * 10)\n",
        "np.zeros(10)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Jfd96IboTzXr"
      },
      "source": [
        "![green-divider](https://user-images.githubusercontent.com/7065401/52071924-c003ad80-2562-11e9-8297-1c6595f8a7ff.png)\n",
        "\n",
        "### Create a numpy array with values ranging from 10 to 49"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "6FPraCyPTzXr",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "858187ed-aae8-4e10-f9d7-d720a48f6695"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26,\n",
              "       27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43,\n",
              "       44, 45, 46, 47, 48, 49])"
            ]
          },
          "metadata": {},
          "execution_count": 6
        }
      ],
      "source": [
        "# your code goes here\n",
        "np.arange(10,50)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cell_type": "solution",
        "id": "7pJ1QNtlTzXs"
      },
      "outputs": [],
      "source": [
        "np.arange(10,50)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kqq_fkcgTzXs"
      },
      "source": [
        "![green-divider](https://user-images.githubusercontent.com/7065401/52071924-c003ad80-2562-11e9-8297-1c6595f8a7ff.png)\n",
        "\n",
        "### Create a numpy matrix of 2*2 integers, filled with ones."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "gbZihRl8TzXs",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9861e8ab-4daf-457f-d567-3d96742b4f81"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[1, 1],\n",
              "       [1, 1]])"
            ]
          },
          "metadata": {},
          "execution_count": 8
        }
      ],
      "source": [
        "# your code goes here\n",
        "np.ones([2,2], dtype=int)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cell_type": "solution",
        "id": "iq27WUDOTzXt"
      },
      "outputs": [],
      "source": [
        "np.ones([2,2], dtype=np.int)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VJ8cO1IuTzXt"
      },
      "source": [
        "![green-divider](https://user-images.githubusercontent.com/7065401/52071924-c003ad80-2562-11e9-8297-1c6595f8a7ff.png)\n",
        "\n",
        "### Create a numpy matrix of 3*2 float numbers, filled with ones."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "mC1ThidWTzXt",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6268fa4a-210e-42ae-f0ba-4344504d0b66"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[1., 1.],\n",
              "       [1., 1.],\n",
              "       [1., 1.]])"
            ]
          },
          "metadata": {},
          "execution_count": 9
        }
      ],
      "source": [
        "# your code goes here\n",
        "np.ones([3,2], dtype=float)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cell_type": "solution",
        "id": "rWzsyDZhTzXt",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 341
        },
        "collapsed": true,
        "outputId": "d2ababb5-8604-4b96-d686-15662b4b6d3f"
      },
      "outputs": [
        {
          "output_type": "error",
          "ename": "AttributeError",
          "evalue": "module 'numpy' has no attribute 'float'.\n`np.float` was a deprecated alias for the builtin `float`. To avoid this error in existing code, use `float` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.float64` here.\nThe aliases was originally deprecated in NumPy 1.20; for more details and guidance see the original release note at:\n    https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-10-06da4d8ebb5c>\u001b[0m in \u001b[0;36m<cell line: 1>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mones\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdtype\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfloat\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/numpy/__init__.py\u001b[0m in \u001b[0;36m__getattr__\u001b[0;34m(attr)\u001b[0m\n\u001b[1;32m    322\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    323\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mattr\u001b[0m \u001b[0;32min\u001b[0m \u001b[0m__former_attrs__\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 324\u001b[0;31m             \u001b[0;32mraise\u001b[0m \u001b[0mAttributeError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0m__former_attrs__\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mattr\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    325\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    326\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mattr\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m'testing'\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mAttributeError\u001b[0m: module 'numpy' has no attribute 'float'.\n`np.float` was a deprecated alias for the builtin `float`. To avoid this error in existing code, use `float` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.float64` here.\nThe aliases was originally deprecated in NumPy 1.20; for more details and guidance see the original release note at:\n    https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations"
          ]
        }
      ],
      "source": [
        "np.ones([3,2], dtype=np.float)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XmNDXoS3TzXu"
      },
      "source": [
        "![green-divider](https://user-images.githubusercontent.com/7065401/52071924-c003ad80-2562-11e9-8297-1c6595f8a7ff.png)\n",
        "\n",
        "### Given the X numpy array, create a new numpy array with the same shape and type as X, filled with ones."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "j07zViCRTzXu",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "886a4588-47db-43fa-e152-3301acbc084a"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([1, 1, 1, 1])"
            ]
          },
          "metadata": {},
          "execution_count": 13
        }
      ],
      "source": [
        "# your code goes here\n",
        "X=np.arange(4, dtype=int)\n",
        "np.ones_like(X)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cell_type": "solution",
        "id": "rvVBHXVFTzXu"
      },
      "outputs": [],
      "source": [
        "X = np.arange(4, dtype=np.int)\n",
        "\n",
        "np.ones_like(X)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mGRwL0QaTzXu"
      },
      "source": [
        "![green-divider](https://user-images.githubusercontent.com/7065401/52071924-c003ad80-2562-11e9-8297-1c6595f8a7ff.png)\n",
        "\n",
        "### Given the X numpy matrix, create a new numpy matrix with the same shape and type as X, filled with zeros."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "0CrGZBmETzXv",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ab8c1c38-3fa6-430c-b9f7-8cb6c458ee6e"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[0, 0, 0],\n",
              "       [0, 0, 0]])"
            ]
          },
          "metadata": {},
          "execution_count": 20
        }
      ],
      "source": [
        "# your code goes here\n",
        "Z=np.array([[1,2,3], [4,5,6]])\n",
        "np.zeros_like(Z)\n",
        "#np.zeros_like(X)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cell_type": "solution",
        "id": "rgoew4ziTzXv"
      },
      "outputs": [],
      "source": [
        "X = np.array([[1,2,3], [4,5,6]], dtype=np.int)\n",
        "\n",
        "np.zeros_like(X)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kAo0hC3bTzXv"
      },
      "source": [
        "![green-divider](https://user-images.githubusercontent.com/7065401/52071924-c003ad80-2562-11e9-8297-1c6595f8a7ff.png)\n",
        "\n",
        "### Create a numpy matrix of 4*4 integers, filled with fives."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "kN769nzzTzXv",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "cadb7b2f-a9a6-41a2-beec-a6f2ddfff6a0"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[5, 5, 5, 5],\n",
              "       [5, 5, 5, 5],\n",
              "       [5, 5, 5, 5],\n",
              "       [5, 5, 5, 5]])"
            ]
          },
          "metadata": {},
          "execution_count": 22
        }
      ],
      "source": [
        "# your code goes here\n",
        "np.ones([4,4], dtype=int) * 5"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cell_type": "solution",
        "id": "7DbW5-ObTzXv"
      },
      "outputs": [],
      "source": [
        "np.ones([4,4], dtype=np.int) * 5"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mSmWZBLQTzXv"
      },
      "source": [
        "![green-divider](https://user-images.githubusercontent.com/7065401/52071924-c003ad80-2562-11e9-8297-1c6595f8a7ff.png)\n",
        "\n",
        "### Given the X numpy matrix, create a new numpy matrix with the same shape and type as X, filled with sevens."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Qk2qp712TzXv",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "07062e8d-11c5-4fed-fa87-138778080a26"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[7, 7],\n",
              "       [7, 7]])"
            ]
          },
          "metadata": {},
          "execution_count": 23
        }
      ],
      "source": [
        "# your code goes here\n",
        "X = np.array([[2,3], [6,2]], dtype=int)\n",
        "np.ones_like(X) * 7"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cell_type": "solution",
        "id": "g0OKJPZhTzXw"
      },
      "outputs": [],
      "source": [
        "X = np.array([[2,3], [6,2]], dtype=np.int)\n",
        "\n",
        "np.ones_like(X) * 7"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cILkgPX3TzXw"
      },
      "source": [
        "![green-divider](https://user-images.githubusercontent.com/7065401/52071924-c003ad80-2562-11e9-8297-1c6595f8a7ff.png)\n",
        "\n",
        "### Create a 3*3 identity numpy matrix with ones on the diagonal and zeros elsewhere."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "TQe-20RtTzXw",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "aae68d5b-e341-4c2f-fd77-5daaf163ebc2"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[1., 0., 0.],\n",
              "       [0., 1., 0.],\n",
              "       [0., 0., 1.]])"
            ]
          },
          "metadata": {},
          "execution_count": 30
        }
      ],
      "source": [
        "# your code goes here\n",
        "#np.eye(3)\n",
        "np.identity(3)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cell_type": "solution",
        "id": "QY_UVWQUTzXw"
      },
      "outputs": [],
      "source": [
        "#np.eye(3)\n",
        "np.identity(3)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EuDh3YJeTzXw"
      },
      "source": [
        "![green-divider](https://user-images.githubusercontent.com/7065401/52071924-c003ad80-2562-11e9-8297-1c6595f8a7ff.png)\n",
        "\n",
        "### Create a numpy array, filled with 3 random integer values between 1 and 10."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "TV7PZFDzTzXw",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "30a06597-bee4-4e89-9c38-ad0c8ff700f1"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([3, 7, 2])"
            ]
          },
          "metadata": {},
          "execution_count": 40
        }
      ],
      "source": [
        "# your code goes here\n",
        "np.random.randint(10, size=3)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cell_type": "solution",
        "id": "hiQoXV_BTzXx"
      },
      "outputs": [],
      "source": [
        "np.random.randint(10, size=3)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HUJK93P_TzXx"
      },
      "source": [
        "![green-divider](https://user-images.githubusercontent.com/7065401/52071924-c003ad80-2562-11e9-8297-1c6595f8a7ff.png)\n",
        "\n",
        "### Create a 3\\*3\\*3 numpy matrix, filled with random float values."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "NJ49tPWMTzXx",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d60a8951-f06e-4fb1-a8ca-03b65178346c"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[[0.53203826, 0.92752511, 0.95461908],\n",
              "        [0.88335514, 0.85925539, 0.99904886],\n",
              "        [0.51552677, 0.73963727, 0.1051062 ]],\n",
              "\n",
              "       [[0.92801787, 0.04247165, 0.8600438 ],\n",
              "        [0.92291895, 0.1757769 , 0.38505245],\n",
              "        [0.2806806 , 0.79970173, 0.9506112 ]],\n",
              "\n",
              "       [[0.34758966, 0.37513653, 0.7085047 ],\n",
              "        [0.37982314, 0.46263697, 0.15414081],\n",
              "        [0.12857046, 0.88334356, 0.097606  ]]])"
            ]
          },
          "metadata": {},
          "execution_count": 43
        }
      ],
      "source": [
        "# your code goes here\n",
        "np.random.random((3,3,3))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cell_type": "solution",
        "id": "HTRkl7HVTzXx",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ec51cc8e-c929-4110-9288-1df5153a9330"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[[ 1.11990956,  1.15739827,  0.59561413],\n",
              "        [ 0.26687989,  0.41061252,  1.27821713],\n",
              "        [-0.46201895, -0.71045788, -1.01989518]],\n",
              "\n",
              "       [[ 1.04032518, -0.50269914, -0.7407166 ],\n",
              "        [-0.2609759 ,  1.14032485, -0.16591727],\n",
              "        [-0.08669687, -0.64339653,  0.57180959]],\n",
              "\n",
              "       [[ 0.07101992, -1.1175794 , -0.0541562 ],\n",
              "        [ 0.48988346, -0.93289717, -0.70018209],\n",
              "        [-0.02439495,  2.06717517, -0.2243404 ]]])"
            ]
          },
          "metadata": {},
          "execution_count": 44
        }
      ],
      "source": [
        "#np.random.random((3,3,3))\n",
        "np.random.randn(3,3,3) # 0 to 1 floats"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RD9Fs2cwTzXx"
      },
      "source": [
        "![green-divider](https://user-images.githubusercontent.com/7065401/52071924-c003ad80-2562-11e9-8297-1c6595f8a7ff.png)\n",
        "\n",
        "### Given the X python list convert it to an Y numpy array"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "IQaxMwZgTzXx"
      },
      "outputs": [],
      "source": [
        "# your code goes here\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cell_type": "solution",
        "id": "CTGtwxURTzXx",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e8ca129c-3c15-4f17-feee-dd5ba642e746"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1, 2, 3] <class 'list'>\n",
            "[1 2 3] <class 'numpy.ndarray'>\n"
          ]
        }
      ],
      "source": [
        "X = [1, 2, 3]\n",
        "print(X, type(X))\n",
        "\n",
        "Y = np.array(X)\n",
        "print(Y, type(Y)) # different type"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7Y8tksHGTzXy"
      },
      "source": [
        "![green-divider](https://user-images.githubusercontent.com/7065401/52071924-c003ad80-2562-11e9-8297-1c6595f8a7ff.png)\n",
        "\n",
        "### Given the X numpy array, make a copy and store it on Y."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "KZY1tLsGTzXy",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a99750ae-5c52-488f-9405-24dcb6ce0331"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[3 2 1] 139964917899952\n",
            "[3 2 1] 139964917904656\n"
          ]
        }
      ],
      "source": [
        "# your code goes here\n",
        "x = np.array([3,2,1])\n",
        "print(x, id(x))\n",
        "\n",
        "y=np.copy(x)\n",
        "print(y, id(y))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cell_type": "solution",
        "id": "Z2_OHBLJTzXy",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "65780d36-1bd8-47a8-e6f2-1d213d6bae39"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[5 2 3] 139964916559920\n",
            "[5 2 3] 139964916581072\n"
          ]
        }
      ],
      "source": [
        "X = np.array([5,2,3], dtype=int)\n",
        "print(X, id(X))\n",
        "\n",
        "Y = np.copy(X)\n",
        "print(Y, id(Y)) # different id"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uog4fkmOTzXy"
      },
      "source": [
        "![green-divider](https://user-images.githubusercontent.com/7065401/52071924-c003ad80-2562-11e9-8297-1c6595f8a7ff.png)\n",
        "\n",
        "### Create a numpy array with numbers from 1 to 10"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "TXtESEmhTzXy",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1ced90c5-ccf2-4baa-e39c-f38648bceb2b"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10])"
            ]
          },
          "metadata": {},
          "execution_count": 55
        }
      ],
      "source": [
        "# your code goes here\n",
        "np.arange(1, 11)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cell_type": "solution",
        "id": "e0snQYHyTzXz"
      },
      "outputs": [],
      "source": [
        "np.arange(1, 11)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VGTCipOHTzXz"
      },
      "source": [
        "![green-divider](https://user-images.githubusercontent.com/7065401/52071924-c003ad80-2562-11e9-8297-1c6595f8a7ff.png)\n",
        "\n",
        "### Create a numpy array with the odd numbers between 1 to 10"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "j0Dl1W-STzXz",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1ba81da3-ef84-49f0-f49d-1f1577ee1678"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([1, 3, 5, 7, 9])"
            ]
          },
          "metadata": {},
          "execution_count": 59
        }
      ],
      "source": [
        "# your code goes here\n",
        "np.arange(1,11,2)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cell_type": "solution",
        "id": "26b1i4jcTzXz"
      },
      "outputs": [],
      "source": [
        "np.arange(1, 11, 2)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hf7LxFHeTzXz"
      },
      "source": [
        "![green-divider](https://user-images.githubusercontent.com/7065401/52071924-c003ad80-2562-11e9-8297-1c6595f8a7ff.png)\n",
        "\n",
        "### Create a numpy array with numbers from 1 to 10, in descending order."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "M8iDKQ0QTzXz",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1b02030b-a17d-42f2-8e85-89dae1b35968"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([10,  9,  8,  7,  6,  5,  4,  3,  2,  1])"
            ]
          },
          "metadata": {},
          "execution_count": 60
        }
      ],
      "source": [
        "# your code goes here\n",
        "np.arange(1,11)[::-1]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cell_type": "solution",
        "id": "odd7ZWI_TzXz"
      },
      "outputs": [],
      "source": [
        "np.arange(1, 11)[::-1]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "why3jikOTzX0"
      },
      "source": [
        "![green-divider](https://user-images.githubusercontent.com/7065401/52071924-c003ad80-2562-11e9-8297-1c6595f8a7ff.png)\n",
        "\n",
        "### Create a 3*3 numpy matrix, filled with values ranging from 0 to 8"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ztXbqeXLTzX0",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "abbc149b-aab9-4c6f-cc8d-d7c847ffe351"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[0, 1, 2],\n",
              "       [3, 4, 5],\n",
              "       [6, 7, 8]])"
            ]
          },
          "metadata": {},
          "execution_count": 61
        }
      ],
      "source": [
        "# your code goes here\n",
        "np.arange(9).reshape(3,3)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cell_type": "solution",
        "id": "lf7hODi6TzX0"
      },
      "outputs": [],
      "source": [
        "np.arange(9).reshape(3,3)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AQKe5zgQTzX0"
      },
      "source": [
        "![green-divider](https://user-images.githubusercontent.com/7065401/52071924-c003ad80-2562-11e9-8297-1c6595f8a7ff.png)\n",
        "\n",
        "### Show the memory size of the given Z numpy matrix"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "YwE6DOkmTzX0",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3f71dd70-c691-47d8-f1b4-1151e3789eff"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "800 bytes\n"
          ]
        }
      ],
      "source": [
        "# your code goes here\n",
        "z=np.ones((10,10))\n",
        "print(\"%d bytes\" % (z.size * z.itemsize))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cell_type": "solution",
        "scrolled": true,
        "id": "KecM183FTzX0"
      },
      "outputs": [],
      "source": [
        "Z = np.zeros((10,10))\n",
        "\n",
        "print(\"%d bytes\" % (Z.size * Z.itemsize))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mqPeAohSTzX1"
      },
      "source": [
        "![purple-divider](https://user-images.githubusercontent.com/7065401/52071927-c1cd7100-2562-11e9-908a-dde91ba14e59.png)\n",
        "\n",
        "## Array indexation\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mU-GBJlzTzX1"
      },
      "source": [
        "### Given the X numpy array, show it's first element"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "rW_TPj4LTzX1"
      },
      "outputs": [],
      "source": [
        "# your code goes here\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cell_type": "solution",
        "id": "ZLGN_Y5ITzX1",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "b91b39a3-51ca-4c14-eea3-23d936d7e897"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'A'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 73
        }
      ],
      "source": [
        "X = np.array(['A','B','C','D','E'])\n",
        "\n",
        "X[0]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "f0hxEXqrTzX1"
      },
      "source": [
        "![green-divider](https://user-images.githubusercontent.com/7065401/52071924-c003ad80-2562-11e9-8297-1c6595f8a7ff.png)\n",
        "\n",
        "### Given the X numpy array, show it's last element"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "11v1imbBTzX1"
      },
      "outputs": [],
      "source": [
        "# your code goes here\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cell_type": "solution",
        "id": "DSvLPr8BTzX1",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "c8e52636-7819-48ed-ebe4-941617e71a42"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'E'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 75
        }
      ],
      "source": [
        "X = np.array(['A','B','C','D','E'])\n",
        "\n",
        "#print(X[len(X)-1])\n",
        "X[-1]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ccAOdgW-TzX2"
      },
      "source": [
        "![green-divider](https://user-images.githubusercontent.com/7065401/52071924-c003ad80-2562-11e9-8297-1c6595f8a7ff.png)\n",
        "\n",
        "### Given the X numpy array, show it's first three elements"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "-gDCx2BNTzX2"
      },
      "outputs": [],
      "source": [
        "# your code goes here\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cell_type": "solution",
        "id": "0frTXId4TzX2"
      },
      "outputs": [],
      "source": [
        "X = np.array(['A','B','C','D','E'])\n",
        "\n",
        "X[0:3] # remember! elements start at zero index"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aQfJ_8t0TzX2"
      },
      "source": [
        "![green-divider](https://user-images.githubusercontent.com/7065401/52071924-c003ad80-2562-11e9-8297-1c6595f8a7ff.png)\n",
        "\n",
        "### Given the X numpy array, show all middle elements"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "LoTb-cHyTzX2"
      },
      "outputs": [],
      "source": [
        "# your code goes here\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cell_type": "solution",
        "id": "M5RQ4zXBTzX2",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e63f5a2c-4451-4d76-8495-81da4ebedb87"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array(['B', 'C', 'D'], dtype='<U1')"
            ]
          },
          "metadata": {},
          "execution_count": 76
        }
      ],
      "source": [
        "X = np.array(['A','B','C','D','E'])\n",
        "\n",
        "X[1:-1]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eTg_zgTbTzX2"
      },
      "source": [
        "![green-divider](https://user-images.githubusercontent.com/7065401/52071924-c003ad80-2562-11e9-8297-1c6595f8a7ff.png)\n",
        "\n",
        "### Given the X numpy array, show the elements in reverse position"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "GUdxXjyzTzX3"
      },
      "outputs": [],
      "source": [
        "# your code goes here\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cell_type": "solution",
        "id": "c0xS79_iTzX3",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "45bfb47f-a960-4706-b404-4b8ff0321b55"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array(['E', 'D', 'C', 'B', 'A'], dtype='<U1')"
            ]
          },
          "metadata": {},
          "execution_count": 77
        }
      ],
      "source": [
        "X = np.array(['A','B','C','D','E'])\n",
        "\n",
        "X[::-1]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ydxUCFV_TzX3"
      },
      "source": [
        "![green-divider](https://user-images.githubusercontent.com/7065401/52071924-c003ad80-2562-11e9-8297-1c6595f8a7ff.png)\n",
        "\n",
        "### Given the X numpy array, show the elements in an odd position"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "kY6UZSKdTzX3"
      },
      "outputs": [],
      "source": [
        "# your code goes here\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cell_type": "solution",
        "id": "DT6XIRskTzX3",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "754b06c7-9425-4022-94e6-315bf076bbe7"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array(['A', 'C', 'E'], dtype='<U1')"
            ]
          },
          "metadata": {},
          "execution_count": 80
        }
      ],
      "source": [
        "X = np.array(['A','B','C','D','E'])\n",
        "\n",
        "#X[[0, 2, -1]]\n",
        "X[::2]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eFXl0b5MTzX3"
      },
      "source": [
        "![green-divider](https://user-images.githubusercontent.com/7065401/52071924-c003ad80-2562-11e9-8297-1c6595f8a7ff.png)\n",
        "\n",
        "### Given the X numpy matrix, show the first row elements"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "_9MR0shhTzX3"
      },
      "outputs": [],
      "source": [
        "# your code goes here\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cell_type": "solution",
        "id": "Q1uxRoabTzX4",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c2979bb7-e05b-4b70-b7b9-821b9f3b78c7"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([1, 2, 3, 4])"
            ]
          },
          "metadata": {},
          "execution_count": 81
        }
      ],
      "source": [
        "X = np.array([\n",
        "    [1,   2,  3,  4],\n",
        "    [5,   6,  7,  8],\n",
        "    [9,  10, 11, 12],\n",
        "    [13, 14, 15, 16]\n",
        "])\n",
        "\n",
        "X[0]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ILgp4pHlTzX4"
      },
      "source": [
        "![green-divider](https://user-images.githubusercontent.com/7065401/52071924-c003ad80-2562-11e9-8297-1c6595f8a7ff.png)\n",
        "\n",
        "### Given the X numpy matrix, show the last row elements"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "hFdLCsBXTzX4"
      },
      "outputs": [],
      "source": [
        "# your code goes here\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cell_type": "solution",
        "id": "zFo01tqpTzX4",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "bee3f49b-cd98-4a23-de7f-dc10aca5ccaf"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([13, 14, 15, 16])"
            ]
          },
          "metadata": {},
          "execution_count": 83
        }
      ],
      "source": [
        "X = np.array([\n",
        "    [1,   2,  3,  4],\n",
        "    [5,   6,  7,  8],\n",
        "    [9,  10, 11, 12],\n",
        "    [13, 14, 15, 16]\n",
        "])\n",
        "\n",
        "X[-1]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bfTIXRO8TzX4"
      },
      "source": [
        "![green-divider](https://user-images.githubusercontent.com/7065401/52071924-c003ad80-2562-11e9-8297-1c6595f8a7ff.png)\n",
        "\n",
        "### Given the X numpy matrix, show the first element on first row"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "UUmcOv0-TzX4",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1cebfa9e-afb7-47c1-87c8-dae0cf3c67d3"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1"
            ]
          },
          "metadata": {},
          "execution_count": 85
        }
      ],
      "source": [
        "# your code goes here\n",
        "x=np.array([\n",
        "    [1,2,3,4],\n",
        "    [5,6,7,8],\n",
        "    [9,10,11,12],\n",
        "    [13,14,15,16]\n",
        "])\n",
        "x[0][0]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cell_type": "solution",
        "id": "WpJqNatxTzX5",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d756c550-9001-4850-d9e3-629a6526b6c1"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1"
            ]
          },
          "metadata": {},
          "execution_count": 84
        }
      ],
      "source": [
        "X = np.array([\n",
        "    [1,   2,  3,  4],\n",
        "    [5,   6,  7,  8],\n",
        "    [9,  10, 11, 12],\n",
        "    [13, 14, 15, 16]\n",
        "])\n",
        "\n",
        "#X[0][0]\n",
        "X[0, 0]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PKXFlnbSTzX5"
      },
      "source": [
        "![green-divider](https://user-images.githubusercontent.com/7065401/52071924-c003ad80-2562-11e9-8297-1c6595f8a7ff.png)\n",
        "\n",
        "### Given the X numpy matrix, show the last element on last row"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "a3JXemrMTzX5",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "53aa3dc4-4713-44ae-9920-13c0bd888867"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "16"
            ]
          },
          "metadata": {},
          "execution_count": 91
        }
      ],
      "source": [
        "# your code goes here\n",
        "x=np.array([\n",
        "    [1,2,3,4],\n",
        "    [5,6,7,8],\n",
        "    [9,10,11,12],\n",
        "    [13,14,15,16]\n",
        "])\n",
        "\n",
        "x[-1,-1]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cell_type": "solution",
        "id": "-lw89nFWTzX5"
      },
      "outputs": [],
      "source": [
        "X = np.array([\n",
        "    [1,   2,  3,  4],\n",
        "    [5,   6,  7,  8],\n",
        "    [9,  10, 11, 12],\n",
        "    [13, 14, 15, 16]\n",
        "])\n",
        "\n",
        "#X[-1][-1]\n",
        "X[-1, -1]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Bu7rdsM-TzX5"
      },
      "source": [
        "![green-divider](https://user-images.githubusercontent.com/7065401/52071924-c003ad80-2562-11e9-8297-1c6595f8a7ff.png)\n",
        "\n",
        "### Given the X numpy matrix, show the middle row elements"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 95,
      "metadata": {
        "id": "al0nL6dMTzX5",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c19ac89f-e43a-4b60-ce0b-296432050243"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[ 6,  7],\n",
              "       [10, 11]])"
            ]
          },
          "metadata": {},
          "execution_count": 95
        }
      ],
      "source": [
        "# your code goes here\n",
        "x = np.array(\n",
        "    [[1,2,3,4],\n",
        "    [5,6,7,8],\n",
        "    [9,10,11,12],\n",
        "    [13,14,15,16]]\n",
        ")\n",
        "\n",
        "x[1:-1,1:-1]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 96,
      "metadata": {
        "cell_type": "solution",
        "id": "7n-692uJTzX5",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7320787a-bdc6-4b2c-bd25-ca895ab161e6"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[ 6,  7],\n",
              "       [10, 11]])"
            ]
          },
          "metadata": {},
          "execution_count": 96
        }
      ],
      "source": [
        "X = np.array([\n",
        "    [1,   2,  3,  4],\n",
        "    [5,   6,  7,  8],\n",
        "    [9,  10, 11, 12],\n",
        "    [13, 14, 15, 16]\n",
        "])\n",
        "\n",
        "#X[1:-1][1:-1] wrong!\n",
        "X[1:-1, 1:-1]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "joFgpNBxTzX6"
      },
      "source": [
        "![green-divider](https://user-images.githubusercontent.com/7065401/52071924-c003ad80-2562-11e9-8297-1c6595f8a7ff.png)\n",
        "\n",
        "### Given the X numpy matrix, show the first two elements on the first two rows"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 97,
      "metadata": {
        "id": "nw5mzYsKTzX6",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "50fd75f7-681c-4a2c-8047-9767efe97049"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[1, 2],\n",
              "       [5, 6]])"
            ]
          },
          "metadata": {},
          "execution_count": 97
        }
      ],
      "source": [
        "# your code goes here\n",
        "X = np.array([\n",
        "    [1,   2,  3,  4],\n",
        "    [5,   6,  7,  8],\n",
        "    [9,  10, 11, 12],\n",
        "    [13, 14, 15, 16]\n",
        "])\n",
        "X[:2,:2]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 98,
      "metadata": {
        "cell_type": "solution",
        "id": "4odOOOgOTzX6",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "cf782386-4b68-4e8b-b42e-b231e891ee39"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[1, 2],\n",
              "       [5, 6]])"
            ]
          },
          "metadata": {},
          "execution_count": 98
        }
      ],
      "source": [
        "X = np.array([\n",
        "    [1,   2,  3,  4],\n",
        "    [5,   6,  7,  8],\n",
        "    [9,  10, 11, 12],\n",
        "    [13, 14, 15, 16]\n",
        "])\n",
        "\n",
        "#X[:2][:2] wrong!\n",
        "X[0:2, 0:2]\n",
        "#X[:2, :2]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2TO2cm4qTzX6"
      },
      "source": [
        "![green-divider](https://user-images.githubusercontent.com/7065401/52071924-c003ad80-2562-11e9-8297-1c6595f8a7ff.png)\n",
        "\n",
        "### Given the X numpy matrix, show the last two elements on the last two rows"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "n7R02ukgTzX6"
      },
      "outputs": [],
      "source": [
        "# your code goes here\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 99,
      "metadata": {
        "cell_type": "solution",
        "id": "r-hizO2wTzX6",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c36c48bb-b7fa-46f5-c6a5-0b1eb3b12dd1"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[11, 12],\n",
              "       [15, 16]])"
            ]
          },
          "metadata": {},
          "execution_count": 99
        }
      ],
      "source": [
        "X = np.array([\n",
        "    [1,   2,  3,  4],\n",
        "    [5,   6,  7,  8],\n",
        "    [9,  10, 11, 12],\n",
        "    [13, 14, 15, 16]\n",
        "])\n",
        "\n",
        "X[2:, 2:]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3I2topF3TzX6"
      },
      "source": [
        "![purple-divider](https://user-images.githubusercontent.com/7065401/52071927-c1cd7100-2562-11e9-908a-dde91ba14e59.png)\n",
        "\n",
        "## Array manipulation\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VmjKYxGUTzX7"
      },
      "source": [
        "### Convert the given integer numpy array to float"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "8O39VrnDTzX7"
      },
      "outputs": [],
      "source": [
        "# your code goes here\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 101,
      "metadata": {
        "cell_type": "solution",
        "id": "qYmW7klWTzX7",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "96c271ed-e9a5-4f71-caeb-0e95298ded2f"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([-5., -3.,  0., 10., 40.])"
            ]
          },
          "metadata": {},
          "execution_count": 101
        }
      ],
      "source": [
        "X = [-5, -3, 0, 10, 40]\n",
        "\n",
        "np.array(X, float)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QSPZl9veTzX7"
      },
      "source": [
        "![green-divider](https://user-images.githubusercontent.com/7065401/52071924-c003ad80-2562-11e9-8297-1c6595f8a7ff.png)\n",
        "\n",
        "### Reverse the given numpy array (first element becomes last)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "xOgv8hhDTzX7"
      },
      "outputs": [],
      "source": [
        "# your code goes here\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 102,
      "metadata": {
        "cell_type": "solution",
        "id": "glU1hMXoTzX7",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e92425e6-a039-4913-a190-b481b4e2d4c1"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[40, 10, 0, -3, -5]"
            ]
          },
          "metadata": {},
          "execution_count": 102
        }
      ],
      "source": [
        "X = [-5, -3, 0, 10, 40]\n",
        "\n",
        "X[::-1]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EDLFUvy0TzX8"
      },
      "source": [
        "![green-divider](https://user-images.githubusercontent.com/7065401/52071924-c003ad80-2562-11e9-8297-1c6595f8a7ff.png)\n",
        "\n",
        "### Order (sort) the given numpy array"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "n8p6MuAzTzX8"
      },
      "outputs": [],
      "source": [
        "# your code goes here\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 104,
      "metadata": {
        "cell_type": "solution",
        "id": "r9lO_bX7TzX8",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e869cff8-7585-43dc-de82-0d275cd79cc7"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[40, 10, 0, -3, -5]"
            ]
          },
          "metadata": {},
          "execution_count": 104
        }
      ],
      "source": [
        "X = [0, 10, -5, 40, -3]\n",
        "\n",
        "X.sort()\n",
        "X"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Jj5v2urXTzX8"
      },
      "source": [
        "![green-divider](https://user-images.githubusercontent.com/7065401/52071924-c003ad80-2562-11e9-8297-1c6595f8a7ff.png)\n",
        "\n",
        "### Given the X numpy array, set the fifth element equal to 1"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "aD1OWvrVTzX8"
      },
      "outputs": [],
      "source": [
        "# your code goes here\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 105,
      "metadata": {
        "cell_type": "solution",
        "id": "7THh_xixTzX8",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1924286d-2315-4019-a266-81c2dcfb9add"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([0., 0., 0., 0., 1., 0., 0., 0., 0., 0.])"
            ]
          },
          "metadata": {},
          "execution_count": 105
        }
      ],
      "source": [
        "X = np.zeros(10)\n",
        "print(X)\n",
        "\n",
        "X[4] = 1\n",
        "X"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fDAznOtwTzX9"
      },
      "source": [
        "![green-divider](https://user-images.githubusercontent.com/7065401/52071924-c003ad80-2562-11e9-8297-1c6595f8a7ff.png)\n",
        "\n",
        "### Given the X numpy array, change the 50 with a 40"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "EXAdhjWTTzX9"
      },
      "outputs": [],
      "source": [
        "# your code goes here\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "cell_type": "solution",
        "id": "izxq43sUTzX9"
      },
      "outputs": [],
      "source": [
        "X = np.array([10, 20, 30, 50])\n",
        "\n",
        "X[3] = 40\n",
        "X"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iTWm7pVQTzX9"
      },
      "source": [
        "![green-divider](https://user-images.githubusercontent.com/7065401/52071924-c003ad80-2562-11e9-8297-1c6595f8a7ff.png)\n",
        "\n",
        "### Given the X numpy matrix, change the last row with all 1"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "luuvMRMlTzX9"
      },
      "outputs": [],
      "source": [
        "# your code goes here\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 111,
      "metadata": {
        "cell_type": "solution",
        "id": "nBkwWdRrTzX9",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "44930f97-b0c4-4791-afd1-a58a789fd612"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[ 1,  2,  3,  4],\n",
              "       [ 5,  6,  7,  8],\n",
              "       [ 9, 10, 11, 12],\n",
              "       [ 1,  1,  1,  1]])"
            ]
          },
          "metadata": {},
          "execution_count": 111
        }
      ],
      "source": [
        "X = np.array([\n",
        "    [1,   2,  3,  4],\n",
        "    [5,   6,  7,  8],\n",
        "    [9,  10, 11, 12],\n",
        "    [13, 14, 15, 16]\n",
        "])\n",
        "\n",
        "X[-1] = np.array([1, 1, 1, 1])\n",
        "X"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GUYjRcBpTzX9"
      },
      "source": [
        "![green-divider](https://user-images.githubusercontent.com/7065401/52071924-c003ad80-2562-11e9-8297-1c6595f8a7ff.png)\n",
        "\n",
        "### Given the X numpy matrix, change the last item on the last row with a 0"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "DkTBzz3lTzX-"
      },
      "outputs": [],
      "source": [
        "# your code goes here\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 112,
      "metadata": {
        "cell_type": "solution",
        "id": "_2TdVTZlTzX-",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "38dce8d2-0d2a-49ad-fed3-182af21be71f"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[ 1,  2,  3,  4],\n",
              "       [ 5,  6,  7,  8],\n",
              "       [ 9, 10, 11, 12],\n",
              "       [13, 14, 15,  0]])"
            ]
          },
          "metadata": {},
          "execution_count": 112
        }
      ],
      "source": [
        "X = np.array([\n",
        "    [1,   2,  3,  4],\n",
        "    [5,   6,  7,  8],\n",
        "    [9,  10, 11, 12],\n",
        "    [13, 14, 15, 16]\n",
        "])\n",
        "\n",
        "X[-1, -1] = 0\n",
        "X"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6mvs8hQETzX-"
      },
      "source": [
        "![green-divider](https://user-images.githubusercontent.com/7065401/52071924-c003ad80-2562-11e9-8297-1c6595f8a7ff.png)\n",
        "\n",
        "### Given the X numpy matrix, add 5 to every element"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "qjhVkjUDTzX-"
      },
      "outputs": [],
      "source": [
        "# your code goes here\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 113,
      "metadata": {
        "cell_type": "solution",
        "id": "NABL1JlFTzX-",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d52e021b-4254-46af-9954-317643a03223"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[ 6,  7,  8,  9],\n",
              "       [10, 11, 12, 13],\n",
              "       [14, 15, 16, 17],\n",
              "       [18, 19, 20, 21]])"
            ]
          },
          "metadata": {},
          "execution_count": 113
        }
      ],
      "source": [
        "X = np.array([\n",
        "    [1,   2,  3,  4],\n",
        "    [5,   6,  7,  8],\n",
        "    [9,  10, 11, 12],\n",
        "    [13, 14, 15, 16]\n",
        "])\n",
        "\n",
        "X + 5"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BHyW34LLTzX-"
      },
      "source": [
        "![purple-divider](https://user-images.githubusercontent.com/7065401/52071927-c1cd7100-2562-11e9-908a-dde91ba14e59.png)\n",
        "\n",
        "## Boolean arrays _(also called masks)_\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QZwOkqLnTzX-"
      },
      "source": [
        "### Given the X numpy array, make a mask showing negative elements"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 115,
      "metadata": {
        "id": "acp1KuoJTzX_",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1801a8a0-2b19-497e-cc30-f56a26294800"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([ True, False,  True,  True, False, False,  True,  True,  True,\n",
              "       False])"
            ]
          },
          "metadata": {},
          "execution_count": 115
        }
      ],
      "source": [
        "# your code goes here\n",
        "X <= 0"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 114,
      "metadata": {
        "cell_type": "solution",
        "id": "9tSfRTqWTzX_",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "80713684-7cde-4497-a587-7f6fb4a91e19"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([ True, False,  True,  True, False, False,  True,  True,  True,\n",
              "       False])"
            ]
          },
          "metadata": {},
          "execution_count": 114
        }
      ],
      "source": [
        "X = np.array([-1,2,0,-4,5,6,0,0,-9,10])\n",
        "\n",
        "mask = X <= 0\n",
        "mask"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iI1kYST8TzX_"
      },
      "source": [
        "![green-divider](https://user-images.githubusercontent.com/7065401/52071924-c003ad80-2562-11e9-8297-1c6595f8a7ff.png)\n",
        "\n",
        "### Given the X numpy array, get the negative elements"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 119,
      "metadata": {
        "id": "9ZHmt5mWTzX_",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c05333d0-c3ad-4722-8f34-af25cf07a7ad"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([-1, -4, -9])"
            ]
          },
          "metadata": {},
          "execution_count": 119
        }
      ],
      "source": [
        "# your code goes here\n",
        "X = np.array([-1, 2, 0, -4, 5, 6, 0, 0, -9, 10])\n",
        "mask = X<0\n",
        "X[mask]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 117,
      "metadata": {
        "cell_type": "solution",
        "id": "ghKkCVNbTzX_",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "b87d6a80-b918-470c-87e8-d0fa7af362c7"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([-1, -4, -9])"
            ]
          },
          "metadata": {},
          "execution_count": 117
        }
      ],
      "source": [
        "X = np.array([-1, 2, 0, -4, 5, 6, 0, 0, -9, 10])\n",
        "\n",
        "mask = X < 0\n",
        "X[mask]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "o1ryenCXTzX_"
      },
      "source": [
        "![green-divider](https://user-images.githubusercontent.com/7065401/52071924-c003ad80-2562-11e9-8297-1c6595f8a7ff.png)\n",
        "\n",
        "### Given the X numpy array, get numbers higher than 5"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "id": "j8ua6CfsTzX_",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "afb03977-1d20-4b79-fe11-3007d1082b10"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([ 6, 10])"
            ]
          },
          "metadata": {},
          "execution_count": 2
        }
      ],
      "source": [
        "# your code goes here\n",
        "X = np.array([-1, 2, 0, -4, 5, 6, 0, 0, -9, 10])\n",
        "g=X>5\n",
        "X[g]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "cell_type": "solution",
        "id": "vs_7PB6xTzYA",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "40f433e1-d377-43bc-a533-88031b8c2766"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([ 6, 10])"
            ]
          },
          "metadata": {},
          "execution_count": 3
        }
      ],
      "source": [
        "X = np.array([-1, 2, 0, -4, 5, 6, 0, 0, -9, 10])\n",
        "\n",
        "mask = X > 5\n",
        "X[mask]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8m36uwxzTzYA"
      },
      "source": [
        "![green-divider](https://user-images.githubusercontent.com/7065401/52071924-c003ad80-2562-11e9-8297-1c6595f8a7ff.png)\n",
        "\n",
        "### Given the X numpy array, get numbers higher than the elements mean"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "id": "eO4VpmfRTzYA",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "49223e0f-ca23-4fd2-ea24-a95e9da4f430"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([ 2,  5,  6, 10])"
            ]
          },
          "metadata": {},
          "execution_count": 4
        }
      ],
      "source": [
        "# your code goes here\n",
        "X = np.array([-1, 2, 0, -4, 5, 6, 0, 0, -9, 10])\n",
        "gm = X.mean()\n",
        "X[X>gm]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "cell_type": "solution",
        "id": "O3ii6p6fTzYA",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "17fb5bed-64b4-484a-c2bc-bb339302384e"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([ 2,  5,  6, 10])"
            ]
          },
          "metadata": {},
          "execution_count": 5
        }
      ],
      "source": [
        "X = np.array([-1, 2, 0, -4, 5, 6, 0, 0, -9, 10])\n",
        "\n",
        "mask = X > X.mean()\n",
        "X[mask]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-mvb357pTzYA"
      },
      "source": [
        "![green-divider](https://user-images.githubusercontent.com/7065401/52071924-c003ad80-2562-11e9-8297-1c6595f8a7ff.png)\n",
        "\n",
        "### Given the X numpy array, get numbers equal to 2 or 10"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "pLEDZy9JTzYA"
      },
      "outputs": [],
      "source": [
        "# your code goes here\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "cell_type": "solution",
        "scrolled": true,
        "id": "rIVe9qHBTzYB",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "042a02e4-7dc6-4092-fd84-96a6a6ceb18a"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([ 2, 10])"
            ]
          },
          "metadata": {},
          "execution_count": 6
        }
      ],
      "source": [
        "X = np.array([-1, 2, 0, -4, 5, 6, 0, 0, -9, 10])\n",
        "\n",
        "mask = (X == 2) | (X == 10)\n",
        "X[mask]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "D5-RQIvBTzYB"
      },
      "source": [
        "![purple-divider](https://user-images.githubusercontent.com/7065401/52071927-c1cd7100-2562-11e9-908a-dde91ba14e59.png)\n",
        "\n",
        "## Logic functions\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "S9_BuzX7TzYB"
      },
      "source": [
        "### Given the X numpy array, return True if none of its elements is zero"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "WWEzmcsjTzYB"
      },
      "outputs": [],
      "source": [
        "# your code goes here\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {
        "cell_type": "solution",
        "id": "tno7c39FTzYB",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5c4c5e42-72bf-411e-a176-8cd2d02810f8"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {},
          "execution_count": 10
        }
      ],
      "source": [
        "X = np.array([-1, 2, 0, -4, 5, 6, 0, 0, -9, 10])\n",
        "\n",
        "X.all()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "I5JTNHcCTzYB"
      },
      "source": [
        "![green-divider](https://user-images.githubusercontent.com/7065401/52071924-c003ad80-2562-11e9-8297-1c6595f8a7ff.png)\n",
        "\n",
        "### Given the X numpy array, return True if any of its elements is zero"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "5SrG3PSOTzYB"
      },
      "outputs": [],
      "source": [
        "# your code goes here\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {
        "cell_type": "solution",
        "id": "t6KC7pIzTzYB",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "b01f3cfe-6169-4472-8ec7-dc68b1b9cd11"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {},
          "execution_count": 11
        }
      ],
      "source": [
        "X = np.array([-1, 2, 0, -4, 5, 6, 0, 0, -9, 10])\n",
        "\n",
        "X.any()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Njm4YcjbTzYC"
      },
      "source": [
        "![purple-divider](https://user-images.githubusercontent.com/7065401/52071927-c1cd7100-2562-11e9-908a-dde91ba14e59.png)\n",
        "\n",
        "## Summary statistics"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Pds5XWBjTzYC"
      },
      "source": [
        "### Given the X numpy array, show the sum of its elements"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "LnHs5qCKTzYC"
      },
      "outputs": [],
      "source": [
        "# your code goes here\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "metadata": {
        "cell_type": "solution",
        "id": "M_QgpRH_TzYC",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "12b8c4d6-d20d-4e96-cca9-a373f843a1b8"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "43"
            ]
          },
          "metadata": {},
          "execution_count": 12
        }
      ],
      "source": [
        "X = np.array([3, 5, 6, 7, 2, 3, 4, 9, 4])\n",
        "\n",
        "#np.sum(X)\n",
        "X.sum()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uJwRQ-G-TzYC"
      },
      "source": [
        "![green-divider](https://user-images.githubusercontent.com/7065401/52071924-c003ad80-2562-11e9-8297-1c6595f8a7ff.png)\n",
        "\n",
        "### Given the X numpy array, show the mean value of its elements"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "KeV8KFuQTzYC"
      },
      "outputs": [],
      "source": [
        "# your code goes here\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "metadata": {
        "cell_type": "solution",
        "id": "cYBBQXLBTzYC",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "03fbf2e9-2179-4fe9-d159-d6c8f2fd1f69"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3.7"
            ]
          },
          "metadata": {},
          "execution_count": 13
        }
      ],
      "source": [
        "X = np.array([1, 2, 0, 4, 5, 6, 0, 0, 9, 10])\n",
        "\n",
        "#np.mean(X)\n",
        "X.mean()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pU-sgLmITzYD"
      },
      "source": [
        "![green-divider](https://user-images.githubusercontent.com/7065401/52071924-c003ad80-2562-11e9-8297-1c6595f8a7ff.png)\n",
        "\n",
        "### Given the X numpy matrix, show the sum of its columns"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "y09ta3lzTzYD"
      },
      "outputs": [],
      "source": [
        "# your code goes here\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 14,
      "metadata": {
        "cell_type": "solution",
        "id": "ybP6wv2OTzYD",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6b59bca1-598e-48b7-f718-0024069fcd0c"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([28, 32, 36, 40])"
            ]
          },
          "metadata": {},
          "execution_count": 14
        }
      ],
      "source": [
        "X = np.array([\n",
        "    [1,   2,  3,  4],\n",
        "    [5,   6,  7,  8],\n",
        "    [9,  10, 11, 12],\n",
        "    [13, 14, 15, 16]\n",
        "])\n",
        "\n",
        "X.sum(axis=0) # remember: axis=0 columns; axis=1 rows"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Wt7QE6AvTzYD"
      },
      "source": [
        "![green-divider](https://user-images.githubusercontent.com/7065401/52071924-c003ad80-2562-11e9-8297-1c6595f8a7ff.png)\n",
        "\n",
        "### Given the X numpy matrix, show the mean value of its rows"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "pj8Nwkd7TzYD"
      },
      "outputs": [],
      "source": [
        "# your code goes here\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 17,
      "metadata": {
        "cell_type": "solution",
        "id": "2MHX6fz3TzYD",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "45a45d53-f1c1-41a1-e078-1476f69d1c4d"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([ 2.5,  6.5, 10.5, 14.5])"
            ]
          },
          "metadata": {},
          "execution_count": 17
        }
      ],
      "source": [
        "X = np.array([\n",
        "    [1,   2,  3,  4],\n",
        "    [5,   6,  7,  8],\n",
        "    [9,  10, 11, 12],\n",
        "    [13, 14, 15, 16]\n",
        "])\n",
        "\n",
        "X.mean(axis=1) # remember: axis=0 columns; axis=1 rows"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hvOWDOhJTzYE"
      },
      "source": [
        "![green-divider](https://user-images.githubusercontent.com/7065401/52071924-c003ad80-2562-11e9-8297-1c6595f8a7ff.png)\n",
        "\n",
        "### Given the X numpy array, show the max value of its elements"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "rZ-ZNxjJTzYE"
      },
      "outputs": [],
      "source": [
        "# your code goes here\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 18,
      "metadata": {
        "cell_type": "solution",
        "id": "lymIxUMVTzYE",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a44f5811-98d3-4afe-ca8f-02fcf12d4c6c"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "10"
            ]
          },
          "metadata": {},
          "execution_count": 18
        }
      ],
      "source": [
        "X = np.array([1, 2, 0, 4, 5, 6, 0, 0, 9, 10])\n",
        "\n",
        "#np.max(X)\n",
        "X.max()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cluAidi0TzYE"
      },
      "source": [
        "![purple-divider](https://user-images.githubusercontent.com/7065401/52071927-c1cd7100-2562-11e9-908a-dde91ba14e59.png)"
      ]
    }
  ],
  "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.8.1"
    },
    "colab": {
      "provenance": [],
      "include_colab_link": true
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}