{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# 3.4 NumPy" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "*Estimated time to complete this notebook: 20 minutes*" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 3.4.1 Limitations of Python Lists" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The normal Python List is just one dimensional.\n", "To make a matrix, we have to nest Python lists:" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "x = [list(range(5)) for N in range(5)]" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[[0, 1, 2, 3, 4],\n", " [0, 1, 2, 3, 4],\n", " [0, 1, 2, 3, 4],\n", " [0, 1, 2, 3, 4],\n", " [0, 1, 2, 3, 4]]" ] }, "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ "x" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "2" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "x[2][2]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Applying an operation to every element is a pain:" ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "tags": [ "raises-exception" ] }, "outputs": [ { "ename": "TypeError", "evalue": "can only concatenate list (not \"int\") to list", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mx\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;36m5\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[0;31mTypeError\u001b[0m: can only concatenate list (not \"int\") to list" ] } ], "source": [ "x + 5" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[[5, 6, 7, 8, 9],\n", " [5, 6, 7, 8, 9],\n", " [5, 6, 7, 8, 9],\n", " [5, 6, 7, 8, 9],\n", " [5, 6, 7, 8, 9]]" ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "[[elem + 5 for elem in row] for row in x]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Common useful operations like transposing a matrix or reshaping a 10 by 10 matrix into a 20 by 5 matrix are not easy to code in raw Python lists." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 3.4.2 The NumPy array" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "NumPy's array type represents a multidimensional matrix $M_{i,j,k...n}$" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The NumPy array seems at first to be just like a list:" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "\n", "my_array = np.array(range(5))" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([0, 1, 2, 3, 4])" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "my_array" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "2" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "my_array[2]" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "Hello\n", "HelloHello\n", "HelloHelloHello\n", "HelloHelloHelloHello\n" ] } ], "source": [ "for element in my_array:\n", " print(\"Hello\" * element)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can also see our first weakness of NumPy arrays versus Python lists:" ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "tags": [ "raises-exception" ] }, "outputs": [ { "ename": "AttributeError", "evalue": "'numpy.ndarray' object has no attribute 'append'", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mmy_array\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[0;31mAttributeError\u001b[0m: 'numpy.ndarray' object has no attribute 'append'" ] } ], "source": [ "my_array.append(4)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "For NumPy arrays, you typically don't change the data size once you've defined your array, whereas for Python lists, you can do this efficiently.\n", "However, you get back lots of goodies in return..." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 3.4.3 Elementwise Operations" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "But most operations can be applied element-wise automatically!" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([2, 3, 4, 5, 6])" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ "my_array + 2" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "These \"vectorized\" operations are very fast: (see [here](https://ipython.readthedocs.io/en/stable/interactive/magics.html#magic-timeit) for more information on the `%%timeit` magic)" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "\n", "big_list = range(10000)\n", "big_array = np.arange(10000)" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "2.24 ms ± 103 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n" ] } ], "source": [ "%%timeit\n", "[x**2 for x in big_list]" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "2.68 µs ± 72.9 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n" ] } ], "source": [ "%%timeit\n", "big_array**2" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 3.4.4 Arange and linspace" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "NumPy has two easy methods for defining floating-point evenly spaced arrays:" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [], "source": [ "x = np.arange(0, 10, 0.1) # Start, stop, step size" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Note that using non-integer step size does not work with Python lists:" ] }, { "cell_type": "code", "execution_count": 16, "metadata": { "tags": [ "raises-exception" ] }, "outputs": [ { "ename": "TypeError", "evalue": "'float' object cannot be interpreted as an integer", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0my\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mlist\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m10\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0.1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[0;31mTypeError\u001b[0m: 'float' object cannot be interpreted as an integer" ] } ], "source": [ "y = list(range(0, 10, 0.1))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Similarly, we can quickly an evenly spaced range of a known size (e.g. for graph plotting):" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [], "source": [ "import math\n", "\n", "values = np.linspace(0, math.pi, 100) # Start, stop, number of steps" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([0. , 0.03173326, 0.06346652, 0.09519978, 0.12693304,\n", " 0.1586663 , 0.19039955, 0.22213281, 0.25386607, 0.28559933,\n", " 0.31733259, 0.34906585, 0.38079911, 0.41253237, 0.44426563,\n", " 0.47599889, 0.50773215, 0.53946541, 0.57119866, 0.60293192,\n", " 0.63466518, 0.66639844, 0.6981317 , 0.72986496, 0.76159822,\n", " 0.79333148, 0.82506474, 0.856798 , 0.88853126, 0.92026451,\n", " 0.95199777, 0.98373103, 1.01546429, 1.04719755, 1.07893081,\n", " 1.11066407, 1.14239733, 1.17413059, 1.20586385, 1.23759711,\n", " 1.26933037, 1.30106362, 1.33279688, 1.36453014, 1.3962634 ,\n", " 1.42799666, 1.45972992, 1.49146318, 1.52319644, 1.5549297 ,\n", " 1.58666296, 1.61839622, 1.65012947, 1.68186273, 1.71359599,\n", " 1.74532925, 1.77706251, 1.80879577, 1.84052903, 1.87226229,\n", " 1.90399555, 1.93572881, 1.96746207, 1.99919533, 2.03092858,\n", " 2.06266184, 2.0943951 , 2.12612836, 2.15786162, 2.18959488,\n", " 2.22132814, 2.2530614 , 2.28479466, 2.31652792, 2.34826118,\n", " 2.37999443, 2.41172769, 2.44346095, 2.47519421, 2.50692747,\n", " 2.53866073, 2.57039399, 2.60212725, 2.63386051, 2.66559377,\n", " 2.69732703, 2.72906028, 2.76079354, 2.7925268 , 2.82426006,\n", " 2.85599332, 2.88772658, 2.91945984, 2.9511931 , 2.98292636,\n", " 3.01465962, 3.04639288, 3.07812614, 3.10985939, 3.14159265])" ] }, "execution_count": 18, "metadata": {}, "output_type": "execute_result" } ], "source": [ "values" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "NumPy comes with 'vectorised' versions of common functions which work element-by-element when applied to arrays:" ] }, { "cell_type": "code", "execution_count": 19, "metadata": { "tags": [ "raises-exception" ] }, "outputs": [ { "data": { "text/plain": [ "[]" ] }, "execution_count": 19, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "from matplotlib import pyplot as plt\n", "\n", "plt.plot(values, np.sin(values))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "So we don't have to use awkward list comprehensions when using these." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 3.4.5 Multi-Dimensional Arrays" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "NumPy's true power comes from multi-dimensional arrays:" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[[0., 0.],\n", " [0., 0.],\n", " [0., 0.],\n", " [0., 0.]],\n", "\n", " [[0., 0.],\n", " [0., 0.],\n", " [0., 0.],\n", " [0., 0.]],\n", "\n", " [[0., 0.],\n", " [0., 0.],\n", " [0., 0.],\n", " [0., 0.]]])" ] }, "execution_count": 20, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.zeros([3, 4, 2]) # 3 arrays with 4 rows and 2 columns each" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Unlike a list-of-lists in Python, we can reshape arrays:" ] }, { "cell_type": "code", "execution_count": 21, "metadata": { "scrolled": true }, "outputs": [ { "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, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,\n", " 34, 35, 36, 37, 38, 39])" ] }, "execution_count": 21, "metadata": {}, "output_type": "execute_result" } ], "source": [ "x = np.array(range(40))\n", "x" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[[ 0, 1],\n", " [ 2, 3],\n", " [ 4, 5],\n", " [ 6, 7],\n", " [ 8, 9]],\n", "\n", " [[10, 11],\n", " [12, 13],\n", " [14, 15],\n", " [16, 17],\n", " [18, 19]],\n", "\n", " [[20, 21],\n", " [22, 23],\n", " [24, 25],\n", " [26, 27],\n", " [28, 29]],\n", "\n", " [[30, 31],\n", " [32, 33],\n", " [34, 35],\n", " [36, 37],\n", " [38, 39]]])" ] }, "execution_count": 22, "metadata": {}, "output_type": "execute_result" } ], "source": [ "y = x.reshape([4, 5, 2]) # 4 Arrays - 5 Rows - 2 Columns\n", "y" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "And index multiple columns at once:" ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "35" ] }, "execution_count": 23, "metadata": {}, "output_type": "execute_result" } ], "source": [ "y[3, 2, 1]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Including selecting on inner axes while taking all from the outermost:" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([ 5, 15, 25, 35])" ] }, "execution_count": 24, "metadata": {}, "output_type": "execute_result" } ], "source": [ "y[:, 2, 1]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "And subselecting ranges:" ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[[20, 21]],\n", "\n", " [[30, 31]]])" ] }, "execution_count": 25, "metadata": {}, "output_type": "execute_result" } ], "source": [ "y[2:, :1, :] # Last 2 axes, 1st row, all columns" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "And [transpose](https://en.wikipedia.org/wiki/Transpose) arrays:" ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[[ 0, 10, 20, 30],\n", " [ 2, 12, 22, 32],\n", " [ 4, 14, 24, 34],\n", " [ 6, 16, 26, 36],\n", " [ 8, 18, 28, 38]],\n", "\n", " [[ 1, 11, 21, 31],\n", " [ 3, 13, 23, 33],\n", " [ 5, 15, 25, 35],\n", " [ 7, 17, 27, 37],\n", " [ 9, 19, 29, 39]]])" ] }, "execution_count": 26, "metadata": {}, "output_type": "execute_result" } ], "source": [ "y.transpose()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "You can get the dimensions of an array with `shape`" ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(4, 5, 2)" ] }, "execution_count": 27, "metadata": {}, "output_type": "execute_result" } ], "source": [ "y.shape # 4 Arrays - 5 Rows - 2 Columns" ] }, { "cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(2, 5, 4)" ] }, "execution_count": 28, "metadata": {}, "output_type": "execute_result" } ], "source": [ "y.transpose().shape # 2 Arrays - 5 Rows - 4 Columns" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Some numpy functions apply by default to the whole array, but can be chosen to act only on certain axes:" ] }, { "cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([[ 0, 1, 2],\n", " [ 3, 4, 5],\n", " [ 6, 7, 8],\n", " [ 9, 10, 11]])" ] }, "execution_count": 29, "metadata": {}, "output_type": "execute_result" } ], "source": [ "x = np.arange(12).reshape(4, 3)\n", "x" ] }, { "cell_type": "code", "execution_count": 30, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([ 1., 4., 7., 10.])" ] }, "execution_count": 30, "metadata": {}, "output_type": "execute_result" } ], "source": [ "x.mean(1) # Mean along the second axis, leaving the first." ] }, { "cell_type": "code", "execution_count": 31, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([4.5, 5.5, 6.5])" ] }, "execution_count": 31, "metadata": {}, "output_type": "execute_result" } ], "source": [ "x.mean(0) # Mean along the first axis, leaving the second." ] }, { "cell_type": "code", "execution_count": 32, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "5.5" ] }, "execution_count": 32, "metadata": {}, "output_type": "execute_result" } ], "source": [ "x.mean() # mean of all axes" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 3.4.6 Array Datatypes" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "A Python `list` can contain data of mixed type:" ] }, { "cell_type": "code", "execution_count": 33, "metadata": {}, "outputs": [], "source": [ "x = [\"hello\", 2, 3.4]" ] }, { "cell_type": "code", "execution_count": 34, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "float" ] }, "execution_count": 34, "metadata": {}, "output_type": "execute_result" } ], "source": [ "type(x[2])" ] }, { "cell_type": "code", "execution_count": 35, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "int" ] }, "execution_count": 35, "metadata": {}, "output_type": "execute_result" } ], "source": [ "type(x[1])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "A NumPy array always contains just one datatype:" ] }, { "cell_type": "code", "execution_count": 36, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array(['hello', '2', '3.4'], dtype='