03-multidimensional-arrays.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Multidimensional arrays\n",
    "\n",
    "We've learned the basics of NumPy and seen how elegant and efficient array programming can be.  In this notebook, we'll look at another powerful feature of NumPy:  manipulating and processing multidimensional arrays.\n",
    "\n",
    "Recall that the `shape` of a one-dimensional array is a one-tuple consisting of the number of elements it contains.  What do you expect the following cell will evaluate to?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "np.arange(10).shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What do you suppose the shape of a *multidimensional* array looks like?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nine = np.array([[1,2,3],[4,5,6],[7,8,9]])\n",
    "nine.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That's right -- it's an *n*-tuple, where *n* is the number of dimensions in the array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "eight = np.array([\n",
    "    [[1,2],[3,4]],\n",
    "    [[5,6],[7,8]]\n",
    "])\n",
    "\n",
    "eight.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This brings us to our first contrast with Python lists.  A multidimensional array in Python is merely a list of lists, so it doesn't need to correspond to a regular array, like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "psix = [[1,2,3], [4,5], [6]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What do you suppose will happen if we try and construct a NumPy array from `psix`?  Consider what you think will happen in each of the following two cells before running them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "npsix = np.array(psix)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "npsix.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Unlike a multidimensional Python list, which is essentially an array of objects, NumPy arrays are stored efficiently as contiguous blocks of memory.  This means we can efficiently *reshape* an array to interpret the values as having a different shape.  What do you expect that each of the following cells will return?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "one = np.arange(27)\n",
    "two = one.reshape(3,9)\n",
    "two_b = one.reshape(9,3)\n",
    "three = two.reshape(3,3,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "one"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "two"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "two_b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "three"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What do you suppose the following cell will return?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "three[0][0][0], one[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How about the next one?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "one[0] = 42\n",
    "three[0][0][0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see, `one` and `three` aren't two separate collections of elements; rather, they're two separate views of the same collection that act as if they have different shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Broadcasting with multidimensional arrays\n",
    "\n",
    "We've learned about broadcasting in the context of single-dimensional arrays and scalars, but broadcasting is especially interesting in the context of multidimensional arrays.  We can use broadcasting to multiply every element in a multidimensional array by a constant, for example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.arange(27).reshape(3,3,3)\n",
    "a * 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also use broadcasting to multiply every row (for example) of a matrix by an array of the same shape, like  this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.arange(12).reshape(3,4)\n",
    "a * np.array([1,0,1,0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the next few cells, write pure-Python code and NumPy code to scale each element of a large multidimensional array of random numbers by 1.5.  Collect timings for each."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "random_numpy = np.random.random((100,100,100))\n",
    "random_py = random_numpy.tolist()\n",
    "pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%time\n",
    "\n",
    "random_numpy * 1.5\n",
    "pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%time\n",
    "\n",
    "# write code to scale each element of random_py by 1.5 here\n",
    "\n",
    "pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Next steps\n",
    "\n",
    "We've just scratched the surface of what you can do with NumPy, and we've tried to focus on important differences from Python lists.  NumPy also has excellent linear algebra and random number generation, for example.  A good way to learn more is to start with the documentation and identify a project you're interested in to dive in -- perhaps related to image processing, linear algebra, finance, or machine learning."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}