pyds_01_introduction_to_numpy.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.9.6"
    },
    "colab": {
      "name": "pyds_01_introduction_to_numpy.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "toc_visible": true,
      "include_colab_link": true
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/cristripoli/Codility/blob/master/pyds_01_introduction_to_numpy.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8N9lqomRs8ox"
      },
      "source": [
        "<img src=\"https://raw.githubusercontent.com/daitan-innovation/daitan-ml-course-resources/main/daitan-header.jpg\" width=\"700\">\n",
        "\n",
        "<br />\n",
        "\n",
        "<span style=\"font-size: 10px; font-style: italic;\">\n",
        "Privileged and confidential. If this content has been received in error, please delete it immediately.\n",
        "<br />\n",
        "Conteúdo confidencial. Se este material foi recebido por engano, por favor apague-o imediatamente.\n",
        "</span>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1PCjRgezJVra"
      },
      "source": [
        "# Trilha de Machine Learning\n",
        "\n",
        "- **Module.** Python for Data Science\n",
        "- **Instructors:**\n",
        "  - Alisson Hayasi da Costa\n",
        "  - Lucas Silveira de Moura\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ovSCSZwmpMlY"
      },
      "source": [
        "# Introduction to NumPy\n",
        "\n",
        "The NumPy library (short for \"Numerical Python\") is a tool for efficiently storing and manipulating large data arrays. For this reason numpy is a fundamental package for any scientific application.\n",
        "\n",
        "> **Why NumPy?**\n",
        ">\n",
        "> Datasets have different shapes and formats. They can be collections of documents, images, sounds, numerical measurements, etc. Although most datasets can be heterogeneous (i.e. various types of data), it is interesting to think of them as arrays of numbers since most algorithms used in machine learning and data science take numeric values as input.\n",
        ">\n",
        "> For example, images can simply be expressed as a matrix of pixels. Sounds can be expressed as one-dimensional arrays of sound amplitude over time. Texts can be converted into various forms of numerical representation, such as binary digits to indicate the frequency of a certain set of words (bag-of-words).\n",
        ">\n",
        "> Therefore, efficient storage and manipulation of numeric arrays is absolutely necessary.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YEEGebmCpMlZ"
      },
      "source": [
        "import numpy as np"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rg5umVaOpMlb"
      },
      "source": [
        "## Building NumPy Arrays\n",
        "\n",
        "The entire Numpy is built around the `ndarray` object.\n",
        "\n",
        "The `ndarray` (aka numpy arrays) is a data structure for efficient storage and operations (much more efficient than any standard Python data structure).\n",
        "\n",
        "More specifically, it is an object that represents multidimensional and homogeneous arrays whose elements have a *fixed size*. Also, the *data type defined for the array describes the format of each element*, such as byte order, number of bytes occupied in memory, etc.\n",
        "\n",
        "(For more information, see the documentation [_ndarray_](https://docs.scipy.org/doc/numpy/reference/generated/numpy.ndarray.html)).\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FoUOvO934YFP"
      },
      "source": [
        "### From Existing Data\n",
        "\n",
        "Numpy arrays can be constructed from any tuple of elements. To do this, the `np.array` function is used.\n",
        "\n",
        "* **`np.array(<array>, dtype=<dtype>, [...])`**\n",
        "    * `<array>`.An object that can be interpreted as a sequence (e.g. list, tuple, string, etc.).\n",
        "    * `<dtype>`. Data type of array elements. If not specified, then the type will be determined as the minimum type needed to keep the objects accurately represented.\n",
        "    * `[...]`. Parameters not described. For more information, see the documentation [np.array](https://docs.scipy.org/doc/numpy/reference/generated/numpy.array.html#numpy.array) "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "B6_LqORIpMlb",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7a71318e-3448-4c8f-cfbe-24b34cf44a8a"
      },
      "source": [
        "# Creating an array from a python list\n",
        "\n",
        "np.array([1, 2, 3, 4])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([1, 2, 3, 4])"
            ]
          },
          "metadata": {},
          "execution_count": 127
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SL3OPlMupMlc",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "17086361-8ef4-43ea-fe08-819ddb9c80c7"
      },
      "source": [
        "# Since numpy arrays are homogeneous (i.e. restricted to the same data type),\n",
        "# if there is more than one data type in the array,\n",
        "# they will be converted to the minimum type needed to keep the objects accurately represented.\n",
        "\n",
        "np.array([1, 2, 3.14])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([1.  , 2.  , 3.14])"
            ]
          },
          "metadata": {},
          "execution_count": 128
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "q4ltDFzPpMld",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a19a9741-c022-4327-c33f-b50cb43b635a"
      },
      "source": [
        "np.array([1.0, 2.0, 3])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([1., 2., 3.])"
            ]
          },
          "metadata": {},
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "m_WnmrWKpMld",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "0a98a332-6dcd-4f4d-af57-bcc8a1cb568d"
      },
      "source": [
        "# We can define the data type by passing the desired type through the `dtype` argument.\n",
        "\n",
        "np.array([1, 2, 3], dtype='float32')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([1., 2., 3.], dtype=float32)"
            ]
          },
          "metadata": {},
          "execution_count": 129
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7ycJlFJlpMld",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3f855563-428e-4d2a-ecbe-d33e4f5ee03c"
      },
      "source": [
        "# To convert the array from one type to another, we use the astype(<dtype>) method.\n",
        "\n",
        "arr_float = np.array([1, 2, 3], dtype='float32')\n",
        "arr_float"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([1., 2., 3.], dtype=float32)"
            ]
          },
          "metadata": {},
          "execution_count": 131
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NT4yoCkQpMle",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "fd70cdcc-c0a1-4104-b8b9-bda5e4020bce"
      },
      "source": [
        "arr_int = arr_float.astype(int)\n",
        "arr_int"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([1, 2, 3])"
            ]
          },
          "metadata": {},
          "execution_count": 132
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ymvio5TapMle",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9aad7554-ac22-4d05-f215-629e3ef86fdd"
      },
      "source": [
        "# If the sequence informed is a list of lists,\n",
        "# the object created is a multidimensional ndarray.\n",
        "\n",
        "np.array([[1, 2, 3], [4, 5, 6]], dtype='float32')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[1., 2., 3.],\n",
              "       [4., 5., 6.]], dtype=float32)"
            ]
          },
          "metadata": {},
          "execution_count": 133
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DL8CDtqwpMlf",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "0c317fdd-fc38-4157-b946-229e8a2dc99e"
      },
      "source": [
        "np.array([range(i, i + 3) for i in [2, 4, 6]])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[2, 3, 4],\n",
              "       [4, 5, 6],\n",
              "       [6, 7, 8]])"
            ]
          },
          "metadata": {},
          "execution_count": 13
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yLvHvM1FpMlf"
      },
      "source": [
        "### From Scratch\n",
        "\n",
        "If you don't have an object to pass but still want to start an ndarray. Just use the `np.empty` routine.\n",
        "\n",
        "* **`np.empty(<shape>, dtype=<dtype>)`**. Returns a new array of dimension <shape> and data type <dtype>, without initializing inputs.\n",
        "    * `<shape>`. Array dimension as tuple or integer.\n",
        "    * `<dtype>`. Desired data type for array. If not specified, the default is 'float64'.\n",
        "\n",
        "Some other very useful and used built-in routines are:    \n",
        "    \n",
        "* **`np.zeros(<shape>, dtype=<dtype>)`**. Returns an array with shape `<shape>` and data type `<dtype>` filled with zeros.\n",
        "\n",
        "\n",
        "* **`np.ones(<shape>, dtype=<dtype>)`**. Returns an array with shape `<shape>` and data type `<dtype>` filled with ones.\n",
        "\n",
        "\n",
        "* **`np.full(<shape>, <fill_value>, dtype=<dtype>)`**. Returns an array with shape `<shape>`, data type `<dtype>` and filled with `<fill_value>`.\n",
        "\n",
        "\n",
        "* **`np.arange(<start>,<stop>,<step>,dtype=<dtype>)`**. Returns an array within the range $[\\textrm{start},\\textrm{stop})$, skipping a `<step>` value at each iteration.\n",
        "\n",
        "* **`np.linspace(<start>, <stop>, num=<num>, dtype=None, [...])`**. Returns an array with `<num>` evenly spaced samples, calculated over the interval [start, stop]."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0xcOCs1ypMlf",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1a297e0b-c8fe-4fae-dfaa-c255ba1bf4ae"
      },
      "source": [
        "# Creating a 10-size unidimensional array\n",
        "\n",
        "np.empty((1, 10))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[4.63755533e-310, 2.14321575e-312, 2.33419537e-312,\n",
              "        2.31297541e-312, 6.79038654e-313, 2.35541533e-312,\n",
              "        6.79038654e-313, 2.35541533e-312, 2.18565567e-312,\n",
              "        0.00000000e+000]])"
            ]
          },
          "metadata": {},
          "execution_count": 135
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "L-pBYtt3pMlh",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "453fdfa5-8c41-4155-d99e-982ef7995872"
      },
      "source": [
        "# Creating an unidimensional array of zeros\n",
        "\n",
        "np.zeros((10,1))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[0.],\n",
              "       [0.],\n",
              "       [0.],\n",
              "       [0.],\n",
              "       [0.],\n",
              "       [0.],\n",
              "       [0.],\n",
              "       [0.],\n",
              "       [0.],\n",
              "       [0.]])"
            ]
          },
          "metadata": {},
          "execution_count": 137
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ndQTpSxEpMli",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d4969f97-2c37-481f-d49b-4420ec598650"
      },
      "source": [
        "# Creating an 2x5 array of ones and dtype int\n",
        "\n",
        "np.ones((2,5), dtype='int')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[1, 1, 1, 1, 1],\n",
              "       [1, 1, 1, 1, 1]])"
            ]
          },
          "metadata": {},
          "execution_count": 16
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qzQIg0UPpMli",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "92a9a679-ceac-43ca-94cd-ff25ab6d0f5f"
      },
      "source": [
        "# Creating an 3x2 array of 3.14s\n",
        "\n",
        "np.full((3,2), 3.14)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[3.14, 3.14],\n",
              "       [3.14, 3.14],\n",
              "       [3.14, 3.14]])"
            ]
          },
          "metadata": {},
          "execution_count": 138
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Jms_vFtepMlj",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f776c1ff-3231-4e95-bcd7-7f3502a331fa"
      },
      "source": [
        "# Creating an array from 0 to 9, dtype int\n",
        "\n",
        "np.arange(0, 10, dtype='int')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
            ]
          },
          "metadata": {},
          "execution_count": 140
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "157CxPuKpMlj",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "628b1dd2-e9fd-44a0-865d-3b6f98c944e6"
      },
      "source": [
        "# Creating an array of evens from 0 to 10\n",
        "\n",
        "np.arange(0, 11, 2, dtype='int')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([ 0,  2,  4,  6,  8, 10])"
            ]
          },
          "metadata": {},
          "execution_count": 141
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Yn_erL1jpMlk",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "00a63cd2-4d3a-411a-d737-3431e3f9806a"
      },
      "source": [
        "# Creating an array of 10 evenly spaced samples from 0 to 10\n",
        "\n",
        "np.linspace(0, 10, 10)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([ 0.        ,  1.11111111,  2.22222222,  3.33333333,  4.44444444,\n",
              "        5.55555556,  6.66666667,  7.77777778,  8.88888889, 10.        ])"
            ]
          },
          "metadata": {},
          "execution_count": 20
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xI2FdXB1pMlk"
      },
      "source": [
        "\n",
        "> **Attention!**\n",
        ">\n",
        ">    It is very common to confuse the shapes of arrays,\n",
        "especially when they are one-dimensional or two-dimensional with an unique row or column.\n",
        ">\n",
        "> Note that `shape=10` indicates a one-dimensional array.\n",
        "> `shape=(1, 10)` or `(10, 1)` (or even `(1,1)`) indicates a two-dimensional array with an unique row (or column)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DEZh-tnIpMlk"
      },
      "source": [
        "### From Randomness\n",
        "\n",
        "To generate random arrays, just use the routines contained in `np.random`\n",
        "\n",
        "* **`np.random.rand(d0, d1, ..., dn)`**. Returns an array according to the dimensions passed as argument and fills it with random samples from an uniform distribution over the range $[0, 1)$. If no dimension is provided, a single random value is returned.\n",
        "\n",
        "* **`np.random.randn(d0, d1, ..., dn)`**. Returns an array according to the dimensions passed as argument and fills it with random samples from a normal distribution (mean 0 and standard deviation 1). If no dimension is provided, a single random value is returned.\n",
        "\n",
        "\n",
        "* **`np.random.randint(<low>, high=<high>, size=<shape>, dtype=<dtype>)`**. Returns an array of dimension `<shape`> whose elements are in the range [`<low>`, `<high>`).\n",
        "\n",
        "* **`np.random.choice(<array>, size=<size>, replace=<replace>, p=<p>)`**. Returns a sample of a ndarray passed as argument.\n",
        "    * `<size>`. Number of samples to be returned\n",
        "    * `<replace>`. If `True`, the same element can be chosen more than once. If `False`, the same element is only chosen once.\n",
        "    * `<p>`. Probability of each element of the array `<array>` be selected.\n",
        "\n",
        "\n",
        "* **`np.random.random_sample(size=<shape>)`**. Returns random numbers in the range $[0,1)$. If no `<shape>` is specified, a single random number is returned (i.e., `'float32'`)\n",
        " "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "w5eyVul5pMll",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8684962b-5a22-48d2-9b85-62d2f3873d65"
      },
      "source": [
        "# array of 5 random numbers\n",
        "\n",
        "np.random.rand(2)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[[0.85889319, 0.38325886],\n",
              "        [0.47483739, 0.02325571]],\n",
              "\n",
              "       [[0.21351637, 0.14932934],\n",
              "        [0.96879965, 0.40300003]]])"
            ]
          },
          "metadata": {},
          "execution_count": 148
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Qghw8j-5pMll",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "fe79b25d-ebfd-4d70-8975-687ca3617127"
      },
      "source": [
        "# normal distribution\n",
        "\n",
        "np.random.randn(10)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([-0.83664575,  0.72675042, -0.38996157, -0.55442921, -1.44610934,\n",
              "        1.39267663,  0.40015279,  0.63928359, -0.45952131, -0.89861893])"
            ]
          },
          "metadata": {},
          "execution_count": 149
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dUTkly2rpMll",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "bf34f483-0b46-4f0c-b22f-8612981eaba4"
      },
      "source": [
        "# 3x3 array with values from 0 to 10\n",
        "\n",
        "np.random.randint(0, 10, (3,3))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[3, 3, 4],\n",
              "       [3, 7, 1],\n",
              "       [0, 4, 4]])"
            ]
          },
          "metadata": {},
          "execution_count": 150
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yr9a8ghxpMlm",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "837b69b6-97df-42fa-d69d-9e1268818b4c"
      },
      "source": [
        "# 5 element sampling without replacement \n",
        "\n",
        "arr = np.arange(0, 10)\n",
        "np.random.choice(arr, 5, replace=False)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([9, 6, 4, 8, 1])"
            ]
          },
          "metadata": {},
          "execution_count": 151
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TPfovyuXpMlm"
      },
      "source": [
        "### Further Reading \n",
        "\n",
        "There are many ways to create numpy arrays from built-in routines. For more ways and information, read the documentation: \n",
        "\n",
        "* [Array creation routines](https://docs.scipy.org/doc/numpy/reference/routines.array-creation.html)\n",
        "* [Random sampling](https://docs.scipy.org/doc/numpy-1.16.0/reference/routines.random.html)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BEzTEnifpMlm"
      },
      "source": [
        "## Handling Data & Arrays\n",
        "\n",
        "Numpy provides several ways to manipulate data from its arrays. The most important categories are:\n",
        "\n",
        "- **Attributes**. Identify the size, shape (dimension), memory consumption and data type of arrays.\n",
        "- **Indexing**. Read and write the value of a specific element of the array.\n",
        "- **Slicing**. Read and write small subarrays of a larger array.\n",
        "- **Reshaping**. Change the size and shape of an array numpy.\n",
        "- **Joining / Splitting**. Combining multiple arrays into one or splitting an array into multiple."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RlBcsp_9pMln"
      },
      "source": [
        "### Attributes\n",
        "\n",
        "Every `ndarray` has several attributes associated with it. The most important are:\n",
        "\n",
        "- `T`. Returns a transposition of the called array.\n",
        "- `ndim`. Number of dimensions of the `ndarray`.\n",
        "- `shape`. `ndarray` dimension.\n",
        "- `size`. Total number of elements in array.\n",
        "- `dtype`. Type of data stored in the `ndarray`.\n",
        "- `itemsize`. Size (in bytes) of the data type stored in the array.\n",
        "- `nbytes`. Total array size (in bytes)\n",
        "\n",
        "> To see all, access the [documentation](https://docs.scipy.org/doc/numpy/reference/generated/numpy.ndarray.html)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bSj3QU9IpMln"
      },
      "source": [
        "arr1 = np.random.randint(10, size=6)\n",
        "arr2 = np.random.randint(10, size=(3, 4))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "F5lTii5ypMln",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a74ce793-49c7-41f4-a0fd-6075049eba01"
      },
      "source": [
        "arr1, arr1.T"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(array([6, 3, 0, 6, 9, 5]), array([6, 3, 0, 6, 9, 5]))"
            ]
          },
          "metadata": {},
          "execution_count": 26
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nySE3PuzpMln",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3bbfc650-601f-4c02-a5f1-39c231c53531"
      },
      "source": [
        "arr2, arr2.T"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(array([[8, 8, 2, 4],\n",
              "        [9, 1, 9, 4],\n",
              "        [7, 0, 0, 1]]), array([[8, 9, 7],\n",
              "        [8, 1, 0],\n",
              "        [2, 9, 0],\n",
              "        [4, 4, 1]]))"
            ]
          },
          "metadata": {},
          "execution_count": 27
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sziAyCX_pMlo",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "4e2b142c-a749-4649-a314-9526bf31efd2"
      },
      "source": [
        "print('Shape: ', arr1.shape)\n",
        "print('Number of Dimensions: ', arr1.ndim)\n",
        "print('Number of elements: ', arr1.size)\n",
        "print('Data type: ', arr1.dtype)\n",
        "print('Element size (bytes): ', arr1.itemsize)\n",
        "print('Array total size (bytes): ', arr1.nbytes)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Shape:  (6,)\n",
            "Number of Dimensions:  1\n",
            "Number of elements:  6\n",
            "Data type:  int64\n",
            "Element size (bytes):  8\n",
            "Array total size (bytes):  48\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZGADjBtRpMlo",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f7eb0c98-bd1b-435b-906c-84de072a0e6e"
      },
      "source": [
        "print('Shape: ', arr2.shape)\n",
        "print('Number of Dimensions: ', arr2.ndim)\n",
        "print('Number of elements: ', arr2.size)\n",
        "print('Data type: ', arr2.dtype)\n",
        "print('Element size (bytes): ', arr2.itemsize)\n",
        "print('Array total size (bytes): ', arr2.nbytes)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Shape:  (3, 4)\n",
            "Number of Dimensions:  2\n",
            "Number of elements:  12\n",
            "Data type:  int64\n",
            "Element size (bytes):  8\n",
            "Array total size (bytes):  96\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1oYx3jXxpMlp"
      },
      "source": [
        "### Inxeding\n",
        "\n",
        "The indexing mechanism of numpy arrays is very similar to that used in python built-in data structures. The only difference is in the use of comma in square brackets to access elements of multidimensional arrays. For example:\n",
        "\n",
        "- `<array>[i,j]`"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PY7GbHFjpMlp",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "db6ce178-86b6-42e2-c70b-e2afef42e91e"
      },
      "source": [
        "arr1 = np.arange(10)\n",
        "arr1"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
            ]
          },
          "metadata": {},
          "execution_count": 154
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ypYKRm_spMlp",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "dd5252e3-ebae-4914-fb0d-927c493fea9c"
      },
      "source": [
        "# Accessing the first and last element of the array\n",
        "\n",
        "arr1[0], arr1[-1]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(0, 9)"
            ]
          },
          "metadata": {},
          "execution_count": 155
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cJV13IvgpMlq",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "b4db5ef7-3fe8-4f86-96dc-02cb60b06cea"
      },
      "source": [
        "arr2 = np.random.randint(10, size=(3, 4))\n",
        "arr2"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[9, 1, 1, 3],\n",
              "       [7, 9, 4, 3],\n",
              "       [5, 1, 5, 4]])"
            ]
          },
          "metadata": {},
          "execution_count": 156
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pOO3uvG-pMlq",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "242d0190-1029-439e-bcaf-8818c026340c"
      },
      "source": [
        "# Acessing the first and last row of the matrix\n",
        "\n",
        "arr2[0], arr2[-1]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(array([9, 1, 1, 3]), array([5, 1, 5, 4]))"
            ]
          },
          "metadata": {},
          "execution_count": 157
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GPt1Y5VCpMlr",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "30680194-554a-466f-832f-4a7e18e67672"
      },
      "source": [
        "# Acessing the first and last elements of the matrix\n",
        "\n",
        "arr2[0,0], arr2[-1,-1]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(9, 4)"
            ]
          },
          "metadata": {},
          "execution_count": 158
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "udaJs3pVpMlr",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e6adc2a7-3b5a-4584-a85f-a90e29f24db8"
      },
      "source": [
        "arr1"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
            ]
          },
          "metadata": {},
          "execution_count": 162
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Rn7SIpiVpMlr"
      },
      "source": [
        "arr1[0] = 3.14"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "blOJyihUpMlr",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "cf24193e-695d-4697-e25a-a309dcb87c6c"
      },
      "source": [
        "arr1\n",
        "\n",
        "# Wait, What? Where is 3.14? xD"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([3, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
            ]
          },
          "metadata": {},
          "execution_count": 164
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Nmfxb2SppMls"
      },
      "source": [
        "### Slicing\n",
        "\n",
        "Like Python sequences, we can use the slicing mechanism to access subarrays from a larger array. The syntax is:\n",
        "- `<array>[start:end:step]`\n",
        "\n",
        "In multidimensional arrays the syntax is the same. Just merge the indexing syntax with the slicing.\n",
        "- `<array>[<row_start>:<row_end>:<step>,<col_start>:<col_end>:<step>]`\n",
        "\n",
        "> **Attention!**\n",
        "> When `step` is a negative integer the syntax becomes `<array>[end:start:step]`.\n",
        ">\n",
        "> This behavior is a convenient way to invert arrays or work inversely."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UR-Yp7uepMls",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6b2c94cd-73cc-4791-fe7b-b5cae39970b9"
      },
      "source": [
        "arr = np.arange(0, 10)\n",
        "arr"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
            ]
          },
          "metadata": {},
          "execution_count": 165
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "B476OKdfpMls",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "b4b09771-c216-4ef8-a078-11f8692c7e1d"
      },
      "source": [
        "# Accessing the first 5 elements\n",
        "\n",
        "arr[:5]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([0, 1, 2, 3, 4])"
            ]
          },
          "metadata": {},
          "execution_count": 167
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_tc-RyO9pMls",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c3cb263c-b43f-4fa3-f0b5-e7571b07cdc5"
      },
      "source": [
        "# Accessing all elements from index 5\n",
        "\n",
        "arr[5:]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([5, 6, 7, 8, 9])"
            ]
          },
          "metadata": {},
          "execution_count": 168
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bFR81uOhpMlt",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "112a93cd-787a-4734-9582-91c0f8a8caeb"
      },
      "source": [
        "# Accessing all elements, two by two\n",
        "\n",
        "arr[::2]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([0, 2, 4, 6, 8])"
            ]
          },
          "metadata": {},
          "execution_count": 169
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "maTeFn-ApMlt",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ef404cca-86f9-45f5-9db0-247cb497e876"
      },
      "source": [
        "# Accessing all elements in reverse\n",
        "\n",
        "arr[::-1]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([9, 8, 7, 6, 5, 4, 3, 2, 1, 0])"
            ]
          },
          "metadata": {},
          "execution_count": 170
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OMMtI8PppMlt",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6aa70a75-cc30-41f4-89c8-1a380d51f349"
      },
      "source": [
        "arr = np.random.randint(10, 100, (5,5))\n",
        "arr"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[33, 40, 52, 45, 69],\n",
              "       [95, 68, 25, 42, 66],\n",
              "       [74, 16, 98, 62, 63],\n",
              "       [93, 98, 36, 89, 80],\n",
              "       [56, 87, 90, 47, 17]])"
            ]
          },
          "metadata": {},
          "execution_count": 171
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NIcUX89-pMlt",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3a4455e4-389e-44a2-d907-d95ae3519d0e"
      },
      "source": [
        "# Accessing the first 3 rows and first 2 columns\n",
        "\n",
        "arr[:3, :2]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[33, 40],\n",
              "       [95, 68],\n",
              "       [74, 16]])"
            ]
          },
          "metadata": {},
          "execution_count": 172
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AoMWlRDwpMlu",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "12c3e0f8-df5e-4587-e9e5-0eabd5143e64"
      },
      "source": [
        "# Accessing all rows and third column\n",
        "\n",
        "arr[:, 2]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([52, 25, 98, 36, 90])"
            ]
          },
          "metadata": {},
          "execution_count": 173
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qp_QV_4epMlu",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "32a36473-9082-4b9b-e81e-c032df312264"
      },
      "source": [
        "# Reversing the rows\n",
        "\n",
        "arr[:, ::-1]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[69, 45, 52, 40, 33],\n",
              "       [66, 42, 25, 68, 95],\n",
              "       [63, 62, 98, 16, 74],\n",
              "       [80, 89, 36, 98, 93],\n",
              "       [17, 47, 90, 87, 56]])"
            ]
          },
          "metadata": {},
          "execution_count": 174
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Pq9vtebvpMlu",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "50302054-0ad3-4677-dec0-80aee9e92d4b"
      },
      "source": [
        "# Reversing rows and columns\n",
        "\n",
        "arr[::-1,::-1]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[17, 47, 90, 87, 56],\n",
              "       [80, 89, 36, 98, 93],\n",
              "       [63, 62, 98, 16, 74],\n",
              "       [66, 42, 25, 68, 95],\n",
              "       [69, 45, 52, 40, 33]])"
            ]
          },
          "metadata": {},
          "execution_count": 175
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zzqDP0TdpMlu"
      },
      "source": [
        "It's important to note that unlike Python's built-in lists, numpy's slicing returns a reference and not a copy of ndarray. So if you modify the subarray the original array is also modified.\n",
        "\n",
        "The good thing about this approach is that when working on large sets of data, you don't need to copy them and, as a result, waste more memory.\n",
        "\n",
        "To create a copy of the array, you need to use the `copy()` method\n",
        "* `<array>.copy()` (In-place)\n",
        "* `np.copy(<array>)` (Copy return)\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hxqQkikcpMlv",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "092a470f-4fc1-4545-aabf-cc7e10062ddf"
      },
      "source": [
        "arr"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[33, 40, 52, 45, 69],\n",
              "       [95, 68, 25, 42, 66],\n",
              "       [74, 16, 98, 62, 63],\n",
              "       [93, 98, 36, 89, 80],\n",
              "       [56, 87, 90, 47, 17]])"
            ]
          },
          "metadata": {},
          "execution_count": 176
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-w_DsZ72pMlv",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7e04c188-abfb-4b74-cadb-06947a46eeb0"
      },
      "source": [
        "arr_sliced = arr[:2,:2]\n",
        "arr_sliced"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[33, 40],\n",
              "       [95, 68]])"
            ]
          },
          "metadata": {},
          "execution_count": 177
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "J7J53n-opMlw",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8bcc6e18-c50e-46d2-c565-954ad4926983"
      },
      "source": [
        "arr_sliced[0,0] = 0\n",
        "arr_sliced"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[ 0, 40],\n",
              "       [95, 68]])"
            ]
          },
          "metadata": {},
          "execution_count": 178
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jjc6DgqQpMlw",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "fee690f2-d8e2-4f4d-e97a-a5fbe5d0a37b"
      },
      "source": [
        "arr"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[ 0, 40, 52, 45, 69],\n",
              "       [95, 68, 25, 42, 66],\n",
              "       [74, 16, 98, 62, 63],\n",
              "       [93, 98, 36, 89, 80],\n",
              "       [56, 87, 90, 47, 17]])"
            ]
          },
          "metadata": {},
          "execution_count": 179
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LfK4B-GzYirb",
        "outputId": "38ee0cc0-caba-4831-cab7-68f4a8928da5"
      },
      "source": [
        "arr[:, 0] = 0\n",
        "arr"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[ 0, 40, 52, 45, 69],\n",
              "       [ 0, 68, 25, 42, 66],\n",
              "       [ 0, 16, 98, 62, 63],\n",
              "       [ 0, 98, 36, 89, 80],\n",
              "       [ 0, 87, 90, 47, 17]])"
            ]
          },
          "metadata": {},
          "execution_count": 180
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-ZSYGV_qpMlx"
      },
      "source": [
        "# Creating a copy of the ndarray\n",
        "\n",
        "arr_cpy = arr.copy()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "F-ITKxLrpMlx",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "823b8a5d-915a-4f76-97f0-5044f437a7ab"
      },
      "source": [
        "arr_cpy"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[ 0, 44, 50, 51, 49],\n",
              "       [29, 36, 15, 30, 79],\n",
              "       [65, 14, 46, 40, 33],\n",
              "       [82, 85, 36, 55, 74],\n",
              "       [90, 99, 52, 36, 15]])"
            ]
          },
          "metadata": {},
          "execution_count": 53
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nrHLJNnPpMlx",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1a56172b-309d-4c7d-b71e-7a431d476e1c"
      },
      "source": [
        "arr_cpy[0,0] = 0\n",
        "arr_cpy"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[ 0, 44, 50, 51, 49],\n",
              "       [29, 36, 15, 30, 79],\n",
              "       [65, 14, 46, 40, 33],\n",
              "       [82, 85, 36, 55, 74],\n",
              "       [90, 99, 52, 36, 15]])"
            ]
          },
          "metadata": {},
          "execution_count": 54
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RKgyjTQrpMlx",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "39ce0b85-825b-4e08-cc9f-e79cab164190"
      },
      "source": [
        "arr"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[ 0, 44, 50, 51, 49],\n",
              "       [29, 36, 15, 30, 79],\n",
              "       [65, 14, 46, 40, 33],\n",
              "       [82, 85, 36, 55, 74],\n",
              "       [90, 99, 52, 36, 15]])"
            ]
          },
          "metadata": {},
          "execution_count": 55
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0LHGH4DspMly"
      },
      "source": [
        "### Reshaping\n",
        "\n",
        "Reshaping is a task that is often performed depending on context. We can reshape a ndarray by using the `reshape()` method.\n",
        "\n",
        "- **`<array>.reshape(<shape>)`**. Resizes the `<array>` to the shape passed as argument.\n",
        "\n",
        "It is possible to resize any ndarray, but the number of elements must be kept (ie, the size of both arrays (`<size>`) must be equal.)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bLM8h1copMly",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c85bcb9e-2ce8-4b6f-e847-e622de12f89e"
      },
      "source": [
        "arr = np.arange(10)\n",
        "arr"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
            ]
          },
          "metadata": {},
          "execution_count": 181
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "owiQOznQpMly",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "53ca8149-6d84-4ad8-b6b0-d2f148a7260c"
      },
      "source": [
        "arr.reshape(5, 2)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[0, 1],\n",
              "       [2, 3],\n",
              "       [4, 5],\n",
              "       [6, 7],\n",
              "       [8, 9]])"
            ]
          },
          "metadata": {},
          "execution_count": 182
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FkevP100pMlz",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e8324111-f4b5-4658-84ea-bca9796355cc"
      },
      "source": [
        "arr.reshape(2, 5)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[0, 1, 2, 3, 4],\n",
              "       [5, 6, 7, 8, 9]])"
            ]
          },
          "metadata": {},
          "execution_count": 183
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8o0915CdpMlz"
      },
      "source": [
        "### Joining\n",
        "\n",
        "To join arrays there are several strategies, being the use of the `np.concatenate`, `np.vstack` and `np.hstack` routines the most adopted.\n",
        "\n",
        "* **`np.concatenate((a1, a2, ...), axis=<eixo>)`**. Joins a sequence of arrays (of equivalent dimensions) along a specific axis.\n",
        "    * `(<a1>, <a2>, ...)`. Sequence of ndarrays (the arrays must have the same shape, except in the dimension corresponding to axis)\n",
        "    * `<eixo>`. The axis along which the arrays will be joined. If axis is None, arrays are flattened before use. Default is 0.\n",
        "\n",
        "\n",
        "* **`np.vstack((a1, a2, ...))`**. Joins a sequence of arrays vertically (row-wise).\n",
        "\n",
        "* **`np.hstack((a1, a2, ...))`**. Joins a sequence of arrays horizontally (columns-wise).\n",
        "\n",
        "* **`np.stack((a1, a2, ...), axis=<eixo>, out=<out>`**. Joins a sequence of arrays on the specified `<axis>` axis."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XHyYeGdkpMlz"
      },
      "source": [
        "x = np.array([1, 2, 3])\n",
        "y = np.array([4, 5, 6])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "W28vcBnJpMl0",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5cc1508c-8027-49ab-b2c1-84a523e41468"
      },
      "source": [
        "x"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([1, 2, 3])"
            ]
          },
          "metadata": {},
          "execution_count": 185
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gZxE1cpdpMl0",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d20d7edc-07d0-40d0-977a-c02ee8176183"
      },
      "source": [
        "y"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([4, 5, 6])"
            ]
          },
          "metadata": {},
          "execution_count": 186
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "p7H2xxXxpMl0",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3b1387ea-5025-4479-a9aa-83e70c08c524"
      },
      "source": [
        "np.concatenate((x, y), axis=None)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([1, 2, 3, 4, 5, 6])"
            ]
          },
          "metadata": {},
          "execution_count": 187
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EydLZwpEpMl0",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 229
        },
        "outputId": "79c1bcfd-9ecf-4cc4-f45e-d84ca05da52d"
      },
      "source": [
        "np.concatenate((x, y), axis=1)\n",
        "\n",
        "# Why?"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "AxisError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mAxisError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-188-d6b108685c4b>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconcatenate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maxis\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m1\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      2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;31m# Why?\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m<__array_function__ internals>\u001b[0m in \u001b[0;36mconcatenate\u001b[0;34m(*args, **kwargs)\u001b[0m\n",
            "\u001b[0;31mAxisError\u001b[0m: axis 1 is out of bounds for array of dimension 1"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "15y7vBTbpMl1"
      },
      "source": [
        "a = np.zeros((3,3))\n",
        "b = np.ones((3,3))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "S-uEhUGypMl1",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5e205d38-3456-4b43-d4f4-755b158e390b"
      },
      "source": [
        "a"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[0., 0., 0.],\n",
              "       [0., 0., 0.],\n",
              "       [0., 0., 0.]])"
            ]
          },
          "metadata": {},
          "execution_count": 192
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IvlKgTK5pMl1",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "19378cbc-8f10-4552-e647-d92ee6010eab"
      },
      "source": [
        "b"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[1., 1., 1.],\n",
              "       [1., 1., 1.],\n",
              "       [1., 1., 1.]])"
            ]
          },
          "metadata": {},
          "execution_count": 193
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Bb2yQAc3pMl1",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e7edab94-a357-4a34-8caa-cacb5160f2d5"
      },
      "source": [
        "# Joining a sequence of arrays along rows (vertically)\n",
        "\n",
        "np.concatenate((a,b), axis=0)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[0., 0., 0.],\n",
              "       [0., 0., 0.],\n",
              "       [0., 0., 0.],\n",
              "       [1., 1., 1.],\n",
              "       [1., 1., 1.],\n",
              "       [1., 1., 1.]])"
            ]
          },
          "metadata": {},
          "execution_count": 67
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YyxaJdpUpMl1",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e65a1b00-a3b3-4ca4-95a6-898a097e5670"
      },
      "source": [
        "# Joining a sequence of arrays along columns (horizontally)\n",
        "\n",
        "np.concatenate((a,b), axis=1)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[0., 0., 0., 1., 1., 1.],\n",
              "       [0., 0., 0., 1., 1., 1.],\n",
              "       [0., 0., 0., 1., 1., 1.]])"
            ]
          },
          "metadata": {},
          "execution_count": 68
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZcMozuLQpMl2"
      },
      "source": [
        "To join arrays of different dimensions, we use `np.vstack` or `np.hstack`"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zWZ1tplSpMl2",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2ebc7829-fcb0-4999-e1bf-cdc1a5e8c30b"
      },
      "source": [
        "a.shape, x.shape, y.shape"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "((3, 3), (3,), (3,))"
            ]
          },
          "metadata": {},
          "execution_count": 69
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DQVy4piGpMl3",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "dc9df573-959c-4ff5-8405-42f3df1ff863"
      },
      "source": [
        "np.vstack((a,x,y))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[0., 0., 0.],\n",
              "       [0., 0., 0.],\n",
              "       [0., 0., 0.],\n",
              "       [1., 2., 3.],\n",
              "       [4., 5., 6.]])"
            ]
          },
          "metadata": {},
          "execution_count": 194
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RbmqfebSpMl3"
      },
      "source": [
        "### Splitting\n",
        "\n",
        "Just as it is possible to concatenate arrays, it is possible to split them. Array division can be done in several ways. The most basic is through slicing.\n",
        "\n",
        "However, given the need to copy the slice, we can use the methods: `np.split`, `np.hsplit` and `np.vsplit`.\n",
        "\n",
        "* **`np.split(<array>, <idx_or_sec>, axis=<axis>)`**. Splits an array into subarrays according to the indicated indexes (or subsequences) on the specified axis (while keeping the number of dimensions).\n",
        "    * `<idx_or_sec>`. If indices_or_sections is an integer, N, the array will be divided into N equal arrays along axis. If such a split is not possible, an error is raised. If indices_or_sections is a 1-D array of sorted integers, the entries indicate where along axis the array is split. If an index exceeds the dimension of the array along axis, an empty sub-array is returned correspondingly.\n",
        "\n",
        "\n",
        "* **`np.vsplit(<array>, <idx_or_sec>, axis=<axis>)`**. Splits an array into subarrays vertically.\n",
        "\n",
        "* **`np.hsplit(<array>, <idx_or_sec>, axis=<axis>)`**. Splits an array into subarrays horizontally.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1LQvGOHSpMl3",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "30dfd8ce-5aa4-45ed-b53e-5196f5021ea6"
      },
      "source": [
        "arr = np.random.randint(0, 10, (3,3))\n",
        "arr"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[8, 5, 8],\n",
              "       [7, 3, 7],\n",
              "       [9, 7, 5]])"
            ]
          },
          "metadata": {},
          "execution_count": 195
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5o3CKp0QpMl4",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "80cca828-f618-4072-a823-bf677162761b"
      },
      "source": [
        "# Dividindo arr em 3 partes iguais sobre as linhas \n",
        "\n",
        "np.split(arr, 3, axis=0)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[array([[8, 5, 8]]), array([[7, 3, 7]]), array([[9, 7, 5]])]"
            ]
          },
          "metadata": {},
          "execution_count": 196
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_JodmoLJpMl4",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f568fff3-5be2-4ff4-abef-8703b1397f93"
      },
      "source": [
        "# Dividindo arr em 3 partes iguais sobre as colunas \n",
        "\n",
        "np.split(arr, 3, axis=1)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[array([[8],\n",
              "        [7],\n",
              "        [9]]), array([[5],\n",
              "        [3],\n",
              "        [7]]), array([[8],\n",
              "        [7],\n",
              "        [5]])]"
            ]
          },
          "metadata": {},
          "execution_count": 197
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "tags": [],
        "id": "4xDWqhJcpMl4",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "15b359aa-94cb-45e7-a98d-2d79c48c709c"
      },
      "source": [
        "arr = np.random.rand(4, 4)\n",
        "arr"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[0.63751387, 0.47328574, 0.26270842, 0.77084785],\n",
              "       [0.46343442, 0.66605687, 0.6461159 , 0.94678493],\n",
              "       [0.88387736, 0.58880533, 0.5588965 , 0.72248956],\n",
              "       [0.99050997, 0.07665214, 0.12670353, 0.9211732 ]])"
            ]
          },
          "metadata": {},
          "execution_count": 198
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "v9bGyT_npMl4",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c26b0193-e63e-4325-b67a-c7b39f5ba099"
      },
      "source": [
        "# Dividindo arr nos índices 2 e 3\n",
        "\n",
        "np.split(arr, [2,3], axis=0)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[array([[0.63751387, 0.47328574, 0.26270842, 0.77084785],\n",
              "        [0.46343442, 0.66605687, 0.6461159 , 0.94678493]]),\n",
              " array([[0.88387736, 0.58880533, 0.5588965 , 0.72248956]]),\n",
              " array([[0.99050997, 0.07665214, 0.12670353, 0.9211732 ]])]"
            ]
          },
          "metadata": {},
          "execution_count": 199
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-ApiAfCQpMl5"
      },
      "source": [
        "# Dividindo arr horizontalmente em 2\n",
        "\n",
        "left, right = np.hsplit(arr, 2)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yUfbZ7TupMl5",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a42e7e4d-ab0e-42e1-9575-6c0b4a3e254c"
      },
      "source": [
        "left, right"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(array([[0.63751387, 0.47328574],\n",
              "        [0.46343442, 0.66605687],\n",
              "        [0.88387736, 0.58880533],\n",
              "        [0.99050997, 0.07665214]]), array([[0.26270842, 0.77084785],\n",
              "        [0.6461159 , 0.94678493],\n",
              "        [0.5588965 , 0.72248956],\n",
              "        [0.12670353, 0.9211732 ]]))"
            ]
          },
          "metadata": {},
          "execution_count": 201
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FabDzkg3pMl5"
      },
      "source": [
        "## Universal Functions\n",
        "\n",
        "Term vectorization refers to the use of optimized, pre-compiled code written in C (together of SIMD instructions set) to perform mathematical operations over a ndarray. Consequently, operations are performed much faster!\n",
        "\n",
        "Universal functions (UFunc) are built-in vectorized functions that operate on ndarrays. In other words, it refers to performing the same operation on multiple elements (just like Python's native `map()`) extremely efficiently.\n",
        "\n",
        "UFUncs can be classified into two types: element-oriented (element-wise) and aggregation."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YB60dk7FpMl9"
      },
      "source": [
        "### Element-wise\n",
        "\n",
        "Element-wise operations are those applied to each element of the ndarray."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PDXefZW1pMl9",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c9447114-7601-4d77-8127-6cf333916bcf"
      },
      "source": [
        "arr = np.arange(0, 5)\n",
        "arr"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([0, 1, 2, 3, 4])"
            ]
          },
          "metadata": {},
          "execution_count": 202
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "stwCtxAspMl9",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "93a52780-f0ae-45ec-f7d5-85c02deacc22"
      },
      "source": [
        "# Adicionando 2 em todos os elementos do array\n",
        "\n",
        "arr + 2"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([2, 3, 4, 5, 6])"
            ]
          },
          "metadata": {},
          "execution_count": 203
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RvJBaltUpMl-",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7d9954cf-0f85-4839-8091-dffeeb5656d0"
      },
      "source": [
        "# Multiplicando por 2 todos os elementos de um ndarray 3x3\n",
        "\n",
        "arr * 2"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([0, 2, 4, 6, 8])"
            ]
          },
          "metadata": {},
          "execution_count": 204
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "p--MWF1ypMl-",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f8d370ef-5243-4063-9f1d-0cc463450f52"
      },
      "source": [
        "arr ** 2"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([ 0,  1,  4,  9, 16])"
            ]
          },
          "metadata": {},
          "execution_count": 205
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iBbuXrd-pMl-"
      },
      "source": [
        "# O quao eficiente? TODO: Translate"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "I_g8KENjpMl-"
      },
      "source": [
        "N = int(1e7)\n",
        "\n",
        "elements = list(range(0, N))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NyYL79dDpMl-",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2a309249-731f-4308-e757-6f9efe826de2"
      },
      "source": [
        "%%timeit\n",
        "\n",
        "[element + 2 for element in elements]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1 loop, best of 5: 953 ms per loop\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "j98kgafJpMl_",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 162
        },
        "outputId": "9cfed4e6-2020-440c-d438-29f6aa3da2ab"
      },
      "source": [
        "arr_elements = np.array(elements)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "NameError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-3-66970bada45c>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0marr_elements\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0melements\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mNameError\u001b[0m: name 'np' is not defined"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "u37fWf61pMl_"
      },
      "source": [
        "%%timeit\n",
        "\n",
        "arr_elements + 2"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Z8rkAGjOpMl_"
      },
      "source": [
        "a = np.array([0, 1, 2])\n",
        "b = np.array([5, 5, 5])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "t0GKLKjypMl_"
      },
      "source": [
        "a + b"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IKyP6rYipMmA"
      },
      "source": [
        "a ** b"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7fiMKnsEpMmA"
      },
      "source": [
        "### Aggregation\n",
        "\n",
        "Aggregation operations are those whose all elements are aggregated to generate a single value.\n",
        "\n",
        "Some examples are:\n",
        "\n",
        "- `sum()`\n",
        "- `mean()`\n",
        "- `std()`\n",
        "- `min()`\n",
        "- `max()`"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lnxmonaTpMmA",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9fc32c9e-5deb-40aa-898d-db4465a85e68"
      },
      "source": [
        "arr = np.arange(0, 20)\n",
        "arr"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16,\n",
              "       17, 18, 19])"
            ]
          },
          "metadata": {},
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FD1S7CgwpMmA",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "46777aef-c982-4a25-e56b-95c47fb3e755"
      },
      "source": [
        "arr.sum()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "190"
            ]
          },
          "metadata": {},
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qByLLtSepMmB",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9dc5a3c1-a6da-435c-f951-cb27419e1215"
      },
      "source": [
        "arr.mean()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "9.5"
            ]
          },
          "metadata": {},
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7mwFAC2WpMmB",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e4a32cd4-ea94-4461-f044-6a2a2b131e0a"
      },
      "source": [
        "arr.min()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0"
            ]
          },
          "metadata": {},
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oynqfEVCpMmB"
      },
      "source": [
        "# How much efficient?"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tnVfSZnYpMmB",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "bfd8c9ed-5e10-4b18-f52e-e59f867e53c2"
      },
      "source": [
        "N"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "10000000"
            ]
          },
          "metadata": {},
          "execution_count": 11
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XB78v5h_pMmC"
      },
      "source": [
        "elements = list(range(0, N))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "toHpZ_KipMmC",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a9c078ae-6bf3-4587-92ce-3d718167fed3"
      },
      "source": [
        "%%timeit\n",
        "\n",
        "soma = 0\n",
        "for element in elements:\n",
        "    soma += element"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1 loop, best of 5: 606 ms per loop\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Fwzgd_2vpMmC"
      },
      "source": [
        "arr = np.arange(0, N)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "K5UwsfEZpMmC",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7abd6349-c70c-42e6-b182-bab7a6aa0ca1"
      },
      "source": [
        "%%timeit\n",
        "\n",
        "arr.sum()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "100 loops, best of 5: 11.1 ms per loop\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HzclJqngpMmC"
      },
      "source": [
        "### Broadcasting\n",
        "\n",
        "_Broadcasting_ is a set of rules for applying binary _ufuncs_ (addition, subtraction, multiplication, etc.) to arrays of different sizes. The three rules that determine the iteration between two arrays with respect to vector functions are:\n",
        "\n",
        "* **Rule 1.** If two arrays have a number of different dimensions, the _shape_ of the array that has the smallest number of dimensions is completed with ones on the main (left) side.\n",
        "* **Rule 2.** If the dimensions of the two arrays do not match, the array with the smallest dimension is increased to match the one with the largest dimension.\n",
        "* **Rule 3.** If it is not possible to fit, then the two arrays are incompatible and an error is generated."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CqWn2OufpMmC",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e156d411-04f9-4978-9ec2-4965797b7c27"
      },
      "source": [
        "M = np.ones((3, 3))\n",
        "M + a"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[1., 2., 3.],\n",
              "       [1., 2., 3.],\n",
              "       [1., 2., 3.]])"
            ]
          },
          "metadata": {},
          "execution_count": 100
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qv_tFE8kpMmD",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "580ab42e-149f-416e-dbf5-38e43712c22d"
      },
      "source": [
        "arr = np.arange(1, 6)\n",
        "arr"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([1, 2, 3, 4, 5])"
            ]
          },
          "metadata": {},
          "execution_count": 101
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wvPI1aeCpMmD",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7eae2172-2115-4636-e773-443d4da477a9"
      },
      "source": [
        "np.add.reduce(arr)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "15"
            ]
          },
          "metadata": {},
          "execution_count": 102
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Mfgu1qMjpMmD",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "cd0ea361-824c-4e3f-d2db-a7eb3d22a98c"
      },
      "source": [
        "np.add.accumulate(arr)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([ 1,  3,  6, 10, 15])"
            ]
          },
          "metadata": {},
          "execution_count": 103
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3CtYmD4vpMmD",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ab7f5965-17b9-44ac-a7d1-57bb8fc4f614"
      },
      "source": [
        "np.min(arr), arr.min()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(1, 1)"
            ]
          },
          "metadata": {},
          "execution_count": 104
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gOLx5WbgpMmD",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f3dabbaa-1eba-475d-ba8b-01e9a8d59423"
      },
      "source": [
        "np.max(arr), arr.max()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(5, 5)"
            ]
          },
          "metadata": {},
          "execution_count": 105
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "W3oXoGUEpMmD",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d3673366-fce2-4050-a1c1-b537221e275d"
      },
      "source": [
        "arr_mean = arr.mean(0)\n",
        "arr_mean"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3.0"
            ]
          },
          "metadata": {},
          "execution_count": 106
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BDLeuyBKpMmE",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a7f44f93-d4f7-4e89-efc1-6bec1afaec48"
      },
      "source": [
        "arr_centered = arr - arr_mean\n",
        "arr_centered"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([-2., -1.,  0.,  1.,  2.])"
            ]
          },
          "metadata": {},
          "execution_count": 107
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4oEszf1opMmE",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "74cb79f1-eb94-4e57-a85a-1d24d360d4a2"
      },
      "source": [
        "arr_centered.mean(0)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.0"
            ]
          },
          "metadata": {},
          "execution_count": 108
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "L0NnqxxcpMmE",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2c97c0ce-b8b7-416d-a557-da36ba063928"
      },
      "source": [
        "arr = np.random.randint(10, size=(3, 4))\n",
        "arr, arr.shape"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(array([[5, 1, 6, 0],\n",
              "        [7, 6, 0, 4],\n",
              "        [2, 1, 1, 8]]), (3, 4))"
            ]
          },
          "metadata": {},
          "execution_count": 109
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Gzsu4lJjpMmE",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "950037e3-8830-456a-b423-dd176221e938"
      },
      "source": [
        "arr.sum(), arr.sum(axis=0), arr.sum(axis=1)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(41, array([14,  8,  7, 12]), array([12, 17, 12]))"
            ]
          },
          "metadata": {},
          "execution_count": 110
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XGiihD5kpMmF"
      },
      "source": [
        "### Boolean Operations"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kBdU5Jo0pMmF"
      },
      "source": [
        "#### Comparison Operators\n",
        "\n",
        "For create boolean masks we use the comparison operators implemented (note that these operators are also ufuncs). The result of these comparison operations is always an array with a boolean data type.\n",
        "\n",
        "All six standard comparison operations are available.\n",
        "\n",
        "| Operator | Equivalent ufunc |\n",
        "|----------|------------------|\n",
        "| ==       | np.equal         |\n",
        "| !=       | np.not_equal     |\n",
        "| <        | np.less          |\n",
        "| <=       | np.less_equal    |\n",
        "| >        | np.greater       |\n",
        "| >=       | np.greater_equal |\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Xxp6HjcGpMmF",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a42574cd-841e-42c2-d4d4-d818a6e7f30b"
      },
      "source": [
        "arr = np.random.randint(0, 10, (3,4))\n",
        "arr"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[3, 2, 1, 7],\n",
              "       [3, 5, 8, 5],\n",
              "       [8, 5, 8, 5]])"
            ]
          },
          "metadata": {},
          "execution_count": 16
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YTJDZX-rpMmF",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "53d5a235-c512-4bec-ddfb-71965f8f27d5"
      },
      "source": [
        "arr == 6"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[False, False, False, False],\n",
              "       [False, False, False, False],\n",
              "       [False, False, False, False]])"
            ]
          },
          "metadata": {},
          "execution_count": 17
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cDHiua5ApMmF",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "041ab5fb-8dca-417e-871a-2857dd4de0a4"
      },
      "source": [
        "arr != 6"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[ True,  True,  True,  True],\n",
              "       [ True,  True,  True,  True],\n",
              "       [ True,  True,  True,  True]])"
            ]
          },
          "metadata": {},
          "execution_count": 18
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VxmEXlSspMmF",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ddd35d5e-3f09-409f-f74c-21d987fc7962"
      },
      "source": [
        "np.less(arr, 6)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[ True,  True, False, False],\n",
              "       [False, False,  True,  True],\n",
              "       [False, False,  True,  True]])"
            ]
          },
          "metadata": {},
          "execution_count": 114
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bBW7ZG3EpMmG",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c95b0399-2021-4f36-c676-88c15e96c620"
      },
      "source": [
        "np.greater(arr, 6)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[False, False,  True,  True],\n",
              "       [ True,  True, False, False],\n",
              "       [ True,  True, False, False]])"
            ]
          },
          "metadata": {},
          "execution_count": 115
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "t6RoUmrJpMmG"
      },
      "source": [
        "#### Logical Operators\n",
        "\n",
        "We can combine the comparison operators with logical operators to create even more powerful boolean masks.\n",
        "\n",
        "| Operator | Equivalent ufunc |\n",
        "|----------|------------------|\n",
        "| &        | np.bitwise_and   |\n",
        "| \\|       | np.bitwise_or    |\n",
        "| ^        | np.bitwise_xor   |\n",
        "| ~        | np.bitwise_not   |\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ff9P3tABpMmG",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3efdc293-a97b-4962-911e-ac73caa56c3f"
      },
      "source": [
        "arr"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[3, 2, 1, 7],\n",
              "       [3, 5, 8, 5],\n",
              "       [8, 5, 8, 5]])"
            ]
          },
          "metadata": {},
          "execution_count": 19
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "f4hfr9ympMmG",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d745aff5-7eb2-458b-b483-67f8816ea6c5"
      },
      "source": [
        "(arr % 2 !=0) & (arr > 5)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[False, False, False,  True],\n",
              "       [False, False, False, False],\n",
              "       [False, False, False, False]])"
            ]
          },
          "metadata": {},
          "execution_count": 20
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OMOBMCrqpMmG"
      },
      "source": [
        "#### Boolean Masks\n",
        "\n",
        "Using Boolean masks is a useful strategy for extracting, modifying, counting or manipulating array values based on some criteria. In NumPy, boolean masking is often the most efficient way to accomplish these types of tasks.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IV3_c3fEpMmG",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9804022a-7534-4e49-e5c0-e7f3457806f8"
      },
      "source": [
        "arr"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[3, 2, 1, 7],\n",
              "       [3, 5, 8, 5],\n",
              "       [8, 5, 8, 5]])"
            ]
          },
          "metadata": {},
          "execution_count": 21
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "28QFDF1RpMmG",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5bd4547f-9832-4050-9363-8d0a9af18d31"
      },
      "source": [
        "mascara = (arr % 2 != 0) & (arr > 5)\n",
        "mascara"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[False, False, False,  True],\n",
              "       [False, False, False, False],\n",
              "       [False, False, False, False]])"
            ]
          },
          "metadata": {},
          "execution_count": 22
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qAP-mL5fpMmH",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "18ef66fa-fd3b-4711-94bf-cd5a781ba078"
      },
      "source": [
        "arr[mascara]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([7])"
            ]
          },
          "metadata": {},
          "execution_count": 23
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-GGB2XaRpMmH"
      },
      "source": [
        "### Appendix\n",
        "\n",
        "#### Row-wise vs Column-wise\n",
        "\n",
        "![axis](https://i.stack.imgur.com/OuyFd.png)\n",
        "<p style=\"font-size: 14px;\">\n",
        "    Source:\n",
        "    <a href=\"https://stackoverflow.com/questions/64428980/why-numpy-apply-along-axis-give-the-same-result-whatever-was-the-axis\" target=\"_blank\">\n",
        "     StackOverflow $-$ Why numpy.apply_along_axis give the same result whatever was the axis?\n",
        "    </a>\n",
        "</p>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UvF-m3e_pMmH"
      },
      "source": [
        "## Reading and Writing Files with NumPy\n",
        "\n",
        "The two main functions for efficiently saving and loading array data to disk are `np.save` and `np.load`. By default arrays are saved in an uncompressed raw binary format with a `.npy` file extension (if the file path does not end in `.npy`, the extension will be appended).\n",
        "\n",
        "* **`np.save(<path>, <arr>, [...])`**. Saves an ndarray `<arr>` to path `<path>` in binary format with extension `.npy`.\n",
        " \n",
        "* **`np.load(<path> [...])`**. Loads a `.npy` file in `<path>`.\n",
        "\n",
        "\n",
        "On the other hand, if the goal is to save or load data in other formats such as *CSV*, we can use the `np.savetxt` and `np.loadtxt` methods.\n",
        "\n",
        "* **`np.savetxt(fname, X, fmt='%.18e', delimiter=' ', header='', [...])`**. Saves a ndarray in text format.\n",
        "    * `fname`. File name (with extension) where the data is to be saved.\n",
        "    * `X`. ndarray (restricted to 1D-arrays and 2D-arrays).\n",
        "    * `delimiter`. Reference character for column separation.\n",
        "\n",
        "\n",
        "* **`numpy.loadtxt(fname, dtype=<class 'float'>, delimiter=None, [...])`**. Loads a text file `fname`."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8jLzHPBVpMmH",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d7a464a1-1ee6-4740-902e-7406a8690d7d"
      },
      "source": [
        "arr = np.random.randint(0, 100, size=(5, 5))\n",
        "arr"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[44, 24, 22, 11, 30],\n",
              "       [22, 56, 11, 37, 57],\n",
              "       [68, 50, 76, 56, 26],\n",
              "       [11,  9, 95, 75, 15],\n",
              "       [64, 26,  3, 23, 17]])"
            ]
          },
          "metadata": {},
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XSFcfGHApMmH"
      },
      "source": [
        "np.save(\"array_de_inteiros_5x5\", arr)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3pUzL8R3pMmH",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5112b0f4-b886-442e-991f-9442cebce311"
      },
      "source": [
        "narr = np.load(\"array_de_inteiros_5x5.npy\")\n",
        "narr"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[44, 24, 22, 11, 30],\n",
              "       [22, 56, 11, 37, 57],\n",
              "       [68, 50, 76, 56, 26],\n",
              "       [11,  9, 95, 75, 15],\n",
              "       [64, 26,  3, 23, 17]])"
            ]
          },
          "metadata": {},
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "R_mrttgdpMmI"
      },
      "source": [
        "np.savetxt(\"array_de_inteiros_5x5.csv\", arr, delimiter=\",\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "--6pLsAZpMmI",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6c8342e2-cdf0-4bb3-dbe1-d5a7ea7aad21"
      },
      "source": [
        "np.loadtxt(\"array_de_inteiros_5x5.csv\", delimiter=\",\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[44., 24., 22., 11., 30.],\n",
              "       [22., 56., 11., 37., 57.],\n",
              "       [68., 50., 76., 56., 26.],\n",
              "       [11.,  9., 95., 75., 15.],\n",
              "       [64., 26.,  3., 23., 17.]])"
            ]
          },
          "metadata": {},
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "B6HWJ_HypMmI"
      },
      "source": [
        "# Tip: Use fmt argument to reduce the filesize\n",
        "\n",
        "np.savetxt(\"array_de_inteiros_5x5.csv\", arr, delimiter=\",\", fmt=\"%.3f\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZUmFJOrSYAln"
      },
      "source": [
        "## References\n",
        "\n",
        "- [Python Data Science Handbook (2016) by Jake VanderPlas](https://jakevdp.github.io/PythonDataScienceHandbook/)\n",
        "- [Python for Data Analysis (2017) by Wes McKinney](https://learning.oreilly.com/library/view/python-for-data/9781491957653/)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OQz74xsapMmI"
      },
      "source": [
        "<span style=\"font-size: 12px; font-style: italic;\">\n",
        "<br /><br />\n",
        "Privileged and confidential. If this content has been received in error, please delete it immediately.\n",
        "<br />\n",
        "Conteúdo confidencial. Se este material foi recebido por engano, por favor apague-o imediatamente.\n",
        "</span>"
      ]
    }
  ]
}