01-DA_Numpy_arrays_creation.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1. Creating Numpy arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Numpy has many different types of data \"containers\": lists, dictionaries, tuples etc. However none of them allows for efficient numerical calculation, in particular not in multi-dimensional cases (think e.g. of operations on images). Numpy has been developed exactly to fill this gap. It provides a new data structure, the **numpy array**, and a large library of operations that allow to: \n",
    "- generate such arrays\n",
    "- combine arrays in different ways (concatenation, stacking etc.)\n",
    "- modify such arrays (projection, extraction of sub-arrays etc.)\n",
    "- apply mathematical operations on them\n",
    "\n",
    "Numpy is the base of almost the entire Python scientific programming stack. Many libraries build on top of Numpy, either by providing specialized functions to operate on them (e.g. scikit-image for image processing) or by creating more complex data containers on top of it. The data science library Pandas that will also be presented in this course is a good example of this with its dataframe structures.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from svg import numpy_to_svg"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.1 What is an array ?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us create the simplest example of an array by transforming a regular Python list into an array (we will see more advanced ways of creating arrays in the next chapters):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mylist = [2,5,3,9,5,2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 5, 3, 9, 5, 2]"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "myarray = np.array(mylist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 5, 3, 9, 5, 2])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myarray"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.ndarray"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(myarray)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We see that ```myarray``` is a Numpy array thanks to the ```array``` specification in the output. The type also says that we have a numpy ndarray (n-dimensional). At this point we don't see a big difference with regular lists, but we'll see in the following sections all the operations we can do with these objects.\n",
    "\n",
    "We can already see a difference with two basic attributes of arrays: their type and shape."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.1.1 Array Type"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Just like when we create regular variables in Python, arrays receive a type when created. Unlike regular list, **all** elements of an array always have the same type. The type of an array can be recovered through the ```.dtype``` method:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('int64')"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myarray.dtype"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Depending on the content of the list, the array will have different types. But the logic of \"maximal complexity\" is kept. For example if we mix integers and floats, we get a float array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1.2, 6. , 7.6, 5. ])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myarray2 = np.array([1.2, 6, 7.6, 5])\n",
    "myarray2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('float64')"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myarray2.dtype"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In general, we have the possibility to assign a type to an array. This is true here, as well as later when we'll create more complex arrays, and is done via the ```dtype``` option: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([  1,   6,   7, 244], dtype=uint8)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myarray2 = np.array([1.2, 6, 7.6, 500], dtype=np.uint8)\n",
    "myarray2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The type of the array can also be changed after creation using the ```.astype()``` method:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('float64')"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myfloat_array = np.array([1.2, 6, 7.6, 500], dtype=np.float)\n",
    "myfloat_array.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('int8')"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myint_array = myfloat_array.astype(np.int8)\n",
    "myint_array.dtype"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.1.2 Array shape\n",
    "\n",
    "A very important property of an array is its **shape** or in other words the dimensions of each axis. That property can be accessed via the ```.shape``` property:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 5, 3, 9, 5, 2])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myarray"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(6,)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myarray.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We see that our simple array has only one dimension of length 6. Now of course we can create more complex arrays. Let's create for example a *list of two lists*:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3],\n",
       "       [4, 5, 6]])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my2d_list = [[1,2,3], [4,5,6]]\n",
    "\n",
    "my2d_array = np.array(my2d_list)\n",
    "my2d_array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 3)"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my2d_array.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We see now that the shape of this array is *two-dimensional*. We also see that we have 2 lists of 3 elements. In fact at this point we should forget that we have a list of lists and simply consider this object as a *matrix* with *two rows and three columns*. We'll use the follwing graphical representation to clarify some concepts:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<svg width=\"250\" height=\"183\" style=\"stroke:rgb(0,0,0);stroke-width:1\" >\n",
       "\n",
       "  <!-- Horizontal lines -->\n",
       "  <line x1=\"0\" y1=\"0\" x2=\"200\" y2=\"0\" style=\"stroke-width:2\" />\n",
       "  <line x1=\"0\" y1=\"66\" x2=\"200\" y2=\"66\" />\n",
       "  <line x1=\"0\" y1=\"133\" x2=\"200\" y2=\"133\" style=\"stroke-width:2\" />\n",
       "\n",
       "  <!-- Vertical lines -->\n",
       "  <line x1=\"0\" y1=\"0\" x2=\"0\" y2=\"133\" style=\"stroke-width:2\" />\n",
       "  <line x1=\"66\" y1=\"0\" x2=\"66\" y2=\"133\" />\n",
       "  <line x1=\"133\" y1=\"0\" x2=\"133\" y2=\"133\" />\n",
       "  <line x1=\"200\" y1=\"0\" x2=\"200\" y2=\"133\" style=\"stroke-width:2\" />\n",
       "\n",
       "  <!-- Colored Rectangle -->\n",
       "  <polygon points=\"0.000000,0.000000 200.000000,0.000000 200.000000,133.333333 0.000000,133.333333\" style=\"fill:#ECB172A0;stroke-width:0\"/>\n",
       "\n",
       "  <!-- Text -->\n",
       "  <text x=\"100.000000\" y=\"153.333333\" font-size=\"1.0rem\" font-weight=\"100\" text-anchor=\"middle\" >3</text>\n",
       "  <text x=\"220.000000\" y=\"66.666667\" font-size=\"1.0rem\" font-weight=\"100\" text-anchor=\"middle\" transform=\"rotate(0,220.000000,66.666667)\">2</text>\n",
       "</svg>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numpy_to_svg(my2d_array)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.2 Creating arrays\n",
    "\n",
    "We have seen that we can turn regular lists into arrays. However this becomes quickly impractical for larger arrays. Numpy offers several functions to create particular arrays. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.2.1 Common simple arrays\n",
    "For example an array full of zeros or ones:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 1., 1.],\n",
       "       [1., 1., 1.]])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "one_array = np.ones((2,3))\n",
    "one_array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0., 0.],\n",
       "       [0., 0., 0.]])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "zero_array = np.zeros((2,3))\n",
    "zero_array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One can also create diagonal matrix:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 0., 0.],\n",
       "       [0., 1., 0.],\n",
       "       [0., 0., 1.]])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.eye(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By default Numpy creates float arrays:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('float64')"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "one_array.dtype"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However as mentioned before, one can impose a type usine the ```dtype``` option:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 1, 1],\n",
       "       [1, 1, 1]], dtype=int8)"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "one_array_int = np.ones((2,3), dtype=np.int8)\n",
    "one_array_int"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('int8')"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "one_array_int.dtype"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.2.2 Copying the shape\n",
    "Often one needs to create arrays of same shape. This can be done with \"like-functions\":"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0., 0.],\n",
       "       [0., 0., 0.]])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "same_shape_array = np.zeros_like(one_array)\n",
    "same_shape_array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 3)"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "one_array.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 3)"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "same_shape_array.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 1., 1.],\n",
       "       [1., 1., 1.]])"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.ones_like(one_array)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.2.3 Complex arrays\n",
    "\n",
    "We are not limited to create arrays containing ones or zeros. Very common operations involve e.g. the creation of arrays containing regularly arrange numbers. For example a \"from-to-by-step\" list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 2, 4, 6, 8])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.arange(0, 10, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Or equidistant numbers between boundaries:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.        , 0.11111111, 0.22222222, 0.33333333, 0.44444444,\n",
       "       0.55555556, 0.66666667, 0.77777778, 0.88888889, 1.        ])"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linspace(0,1, 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Numpy offers in particular a ```random``` submodules that allows one to create arrays containing values from a wide array of distributions. For example, normally distributed:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[16.64156121, 13.38970093, 11.32772287,  7.93713055],\n",
       "       [ 8.33365707, 11.27817138,  9.81766403, 11.11541451],\n",
       "       [12.97743479,  7.1622948 , 12.02417108,  8.64402656]])"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "normal_array = np.random.normal(loc=10, scale=2, size=(3,4))\n",
    "normal_array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[4, 4, 2, 4],\n",
       "       [3, 7, 6, 3],\n",
       "       [6, 5, 5, 4]])"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.poisson(lam=5, size=(3,4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.2.4 Higher dimensions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Until now we have almost only dealt with 1D or 2D arrays that look like a simple grid:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<svg width=\"250\" height=\"150\" style=\"stroke:rgb(0,0,0);stroke-width:1\" >\n",
       "\n",
       "  <!-- Horizontal lines -->\n",
       "  <line x1=\"0\" y1=\"0\" x2=\"200\" y2=\"0\" style=\"stroke-width:2\" />\n",
       "  <line x1=\"0\" y1=\"20\" x2=\"200\" y2=\"20\" />\n",
       "  <line x1=\"0\" y1=\"40\" x2=\"200\" y2=\"40\" />\n",
       "  <line x1=\"0\" y1=\"60\" x2=\"200\" y2=\"60\" />\n",
       "  <line x1=\"0\" y1=\"80\" x2=\"200\" y2=\"80\" />\n",
       "  <line x1=\"0\" y1=\"100\" x2=\"200\" y2=\"100\" style=\"stroke-width:2\" />\n",
       "\n",
       "  <!-- Vertical lines -->\n",
       "  <line x1=\"0\" y1=\"0\" x2=\"0\" y2=\"100\" style=\"stroke-width:2\" />\n",
       "  <line x1=\"20\" y1=\"0\" x2=\"20\" y2=\"100\" />\n",
       "  <line x1=\"40\" y1=\"0\" x2=\"40\" y2=\"100\" />\n",
       "  <line x1=\"60\" y1=\"0\" x2=\"60\" y2=\"100\" />\n",
       "  <line x1=\"80\" y1=\"0\" x2=\"80\" y2=\"100\" />\n",
       "  <line x1=\"100\" y1=\"0\" x2=\"100\" y2=\"100\" />\n",
       "  <line x1=\"120\" y1=\"0\" x2=\"120\" y2=\"100\" />\n",
       "  <line x1=\"140\" y1=\"0\" x2=\"140\" y2=\"100\" />\n",
       "  <line x1=\"160\" y1=\"0\" x2=\"160\" y2=\"100\" />\n",
       "  <line x1=\"180\" y1=\"0\" x2=\"180\" y2=\"100\" />\n",
       "  <line x1=\"200\" y1=\"0\" x2=\"200\" y2=\"100\" style=\"stroke-width:2\" />\n",
       "\n",
       "  <!-- Colored Rectangle -->\n",
       "  <polygon points=\"0.000000,0.000000 200.000000,0.000000 200.000000,100.000000 0.000000,100.000000\" style=\"fill:#ECB172A0;stroke-width:0\"/>\n",
       "\n",
       "  <!-- Text -->\n",
       "  <text x=\"100.000000\" y=\"120.000000\" font-size=\"1.0rem\" font-weight=\"100\" text-anchor=\"middle\" >10</text>\n",
       "  <text x=\"220.000000\" y=\"50.000000\" font-size=\"1.0rem\" font-weight=\"100\" text-anchor=\"middle\" transform=\"rotate(0,220.000000,50.000000)\">5</text>\n",
       "</svg>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myarray = np.ones((5,10))\n",
    "numpy_to_svg(myarray)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We are not limited to create 1 or 2 dimensional arrays. We can basically create any-dimension array. For example in microscopy, images can be volumetric and thus they are 3D arrays in Numpy. For example if we acquired 5 planes of a 10px by 10px image, we would have something like:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "array3D = np.ones((10,10,5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<svg width=\"277\" height=\"367\" style=\"stroke:rgb(0,0,0);stroke-width:1\" >\n",
       "\n",
       "  <!-- Horizontal lines -->\n",
       "  <line x1=\"10\" y1=\"0\" x2=\"127\" y2=\"117\" style=\"stroke-width:2\" />\n",
       "  <line x1=\"10\" y1=\"20\" x2=\"127\" y2=\"137\" />\n",
       "  <line x1=\"10\" y1=\"40\" x2=\"127\" y2=\"157\" />\n",
       "  <line x1=\"10\" y1=\"60\" x2=\"127\" y2=\"177\" />\n",
       "  <line x1=\"10\" y1=\"80\" x2=\"127\" y2=\"197\" />\n",
       "  <line x1=\"10\" y1=\"100\" x2=\"127\" y2=\"217\" />\n",
       "  <line x1=\"10\" y1=\"120\" x2=\"127\" y2=\"237\" />\n",
       "  <line x1=\"10\" y1=\"140\" x2=\"127\" y2=\"257\" />\n",
       "  <line x1=\"10\" y1=\"160\" x2=\"127\" y2=\"277\" />\n",
       "  <line x1=\"10\" y1=\"180\" x2=\"127\" y2=\"297\" />\n",
       "  <line x1=\"10\" y1=\"200\" x2=\"127\" y2=\"317\" style=\"stroke-width:2\" />\n",
       "\n",
       "  <!-- Vertical lines -->\n",
       "  <line x1=\"10\" y1=\"0\" x2=\"10\" y2=\"200\" style=\"stroke-width:2\" />\n",
       "  <line x1=\"21\" y1=\"11\" x2=\"21\" y2=\"211\" />\n",
       "  <line x1=\"33\" y1=\"23\" x2=\"33\" y2=\"223\" />\n",
       "  <line x1=\"45\" y1=\"35\" x2=\"45\" y2=\"235\" />\n",
       "  <line x1=\"57\" y1=\"47\" x2=\"57\" y2=\"247\" />\n",
       "  <line x1=\"68\" y1=\"58\" x2=\"68\" y2=\"258\" />\n",
       "  <line x1=\"80\" y1=\"70\" x2=\"80\" y2=\"270\" />\n",
       "  <line x1=\"92\" y1=\"82\" x2=\"92\" y2=\"282\" />\n",
       "  <line x1=\"104\" y1=\"94\" x2=\"104\" y2=\"294\" />\n",
       "  <line x1=\"115\" y1=\"105\" x2=\"115\" y2=\"305\" />\n",
       "  <line x1=\"127\" y1=\"117\" x2=\"127\" y2=\"317\" style=\"stroke-width:2\" />\n",
       "\n",
       "  <!-- Colored Rectangle -->\n",
       "  <polygon points=\"10.000000,0.000000 127.647059,117.647059 127.647059,317.647059 10.000000,200.000000\" style=\"fill:#ECB172A0;stroke-width:0\"/>\n",
       "\n",
       "  <!-- Horizontal lines -->\n",
       "  <line x1=\"10\" y1=\"0\" x2=\"110\" y2=\"0\" style=\"stroke-width:2\" />\n",
       "  <line x1=\"21\" y1=\"11\" x2=\"121\" y2=\"11\" />\n",
       "  <line x1=\"33\" y1=\"23\" x2=\"133\" y2=\"23\" />\n",
       "  <line x1=\"45\" y1=\"35\" x2=\"145\" y2=\"35\" />\n",
       "  <line x1=\"57\" y1=\"47\" x2=\"157\" y2=\"47\" />\n",
       "  <line x1=\"68\" y1=\"58\" x2=\"168\" y2=\"58\" />\n",
       "  <line x1=\"80\" y1=\"70\" x2=\"180\" y2=\"70\" />\n",
       "  <line x1=\"92\" y1=\"82\" x2=\"192\" y2=\"82\" />\n",
       "  <line x1=\"104\" y1=\"94\" x2=\"204\" y2=\"94\" />\n",
       "  <line x1=\"115\" y1=\"105\" x2=\"215\" y2=\"105\" />\n",
       "  <line x1=\"127\" y1=\"117\" x2=\"227\" y2=\"117\" style=\"stroke-width:2\" />\n",
       "\n",
       "  <!-- Vertical lines -->\n",
       "  <line x1=\"10\" y1=\"0\" x2=\"127\" y2=\"117\" style=\"stroke-width:2\" />\n",
       "  <line x1=\"30\" y1=\"0\" x2=\"147\" y2=\"117\" />\n",
       "  <line x1=\"50\" y1=\"0\" x2=\"167\" y2=\"117\" />\n",
       "  <line x1=\"70\" y1=\"0\" x2=\"187\" y2=\"117\" />\n",
       "  <line x1=\"90\" y1=\"0\" x2=\"207\" y2=\"117\" />\n",
       "  <line x1=\"110\" y1=\"0\" x2=\"227\" y2=\"117\" style=\"stroke-width:2\" />\n",
       "\n",
       "  <!-- Colored Rectangle -->\n",
       "  <polygon points=\"10.000000,0.000000 110.000000,0.000000 227.647059,117.647059 127.647059,117.647059\" style=\"fill:#ECB172A0;stroke-width:0\"/>\n",
       "\n",
       "  <!-- Horizontal lines -->\n",
       "  <line x1=\"127\" y1=\"117\" x2=\"227\" y2=\"117\" style=\"stroke-width:2\" />\n",
       "  <line x1=\"127\" y1=\"137\" x2=\"227\" y2=\"137\" />\n",
       "  <line x1=\"127\" y1=\"157\" x2=\"227\" y2=\"157\" />\n",
       "  <line x1=\"127\" y1=\"177\" x2=\"227\" y2=\"177\" />\n",
       "  <line x1=\"127\" y1=\"197\" x2=\"227\" y2=\"197\" />\n",
       "  <line x1=\"127\" y1=\"217\" x2=\"227\" y2=\"217\" />\n",
       "  <line x1=\"127\" y1=\"237\" x2=\"227\" y2=\"237\" />\n",
       "  <line x1=\"127\" y1=\"257\" x2=\"227\" y2=\"257\" />\n",
       "  <line x1=\"127\" y1=\"277\" x2=\"227\" y2=\"277\" />\n",
       "  <line x1=\"127\" y1=\"297\" x2=\"227\" y2=\"297\" />\n",
       "  <line x1=\"127\" y1=\"317\" x2=\"227\" y2=\"317\" style=\"stroke-width:2\" />\n",
       "\n",
       "  <!-- Vertical lines -->\n",
       "  <line x1=\"127\" y1=\"117\" x2=\"127\" y2=\"317\" style=\"stroke-width:2\" />\n",
       "  <line x1=\"147\" y1=\"117\" x2=\"147\" y2=\"317\" />\n",
       "  <line x1=\"167\" y1=\"117\" x2=\"167\" y2=\"317\" />\n",
       "  <line x1=\"187\" y1=\"117\" x2=\"187\" y2=\"317\" />\n",
       "  <line x1=\"207\" y1=\"117\" x2=\"207\" y2=\"317\" />\n",
       "  <line x1=\"227\" y1=\"117\" x2=\"227\" y2=\"317\" style=\"stroke-width:2\" />\n",
       "\n",
       "  <!-- Colored Rectangle -->\n",
       "  <polygon points=\"127.647059,117.647059 227.647059,117.647059 227.647059,317.647059 127.647059,317.647059\" style=\"fill:#ECB172A0;stroke-width:0\"/>\n",
       "\n",
       "  <!-- Text -->\n",
       "  <text x=\"177.647059\" y=\"337.647059\" font-size=\"1.0rem\" font-weight=\"100\" text-anchor=\"middle\" >5</text>\n",
       "  <text x=\"247.647059\" y=\"217.647059\" font-size=\"1.0rem\" font-weight=\"100\" text-anchor=\"middle\" transform=\"rotate(0,247.647059,217.647059)\">10</text>\n",
       "  <text x=\"58.823529\" y=\"278.823529\" font-size=\"1.0rem\" font-weight=\"100\" text-anchor=\"middle\" transform=\"rotate(45,58.823529,278.823529)\">10</text>\n",
       "</svg>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numpy_to_svg(array3D)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "All the functions and properties that we have seen until now are N-dimensional, i.e. they work in the same way irrespective of the array size."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.3 Importing arrays\n",
    "\n",
    "We have seen until now multiple ways to create arrays. However, most of the time, you will *import* data from some source, either directly as arrays or as lists, and use these data in your analysis."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.3.1 Loading and saving arrays\n",
    "\n",
    "Numpy can efficiently save and load arrays in its own format ```.npy```. Let's create an array and save it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 5.41052227, 11.78370736,  9.22402365,  9.91645679,  9.48495895],\n",
       "       [10.10853493,  8.75839699,  8.26026504, 12.51736441,  9.80407577],\n",
       "       [10.09084097,  7.27962072, 11.05963249, 14.37978527,  9.00654627],\n",
       "       [ 6.01521954, 10.25115807, 10.28647927, 10.12389832,  8.91184397]])"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array_to_save = np.random.normal(10, 2, (4,5))\n",
    "array_to_save"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.save('my_saved_array.npy', array_to_save)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "01-DA_Numpy_arrays_creation.ipynb   98-DA_Numpy_Solutions.ipynb\n",
      "02-DA_Numpy_array_maths.ipynb       99-DA_Pandas_Exercises.ipynb\n",
      "03-DA_Numpy_matplotlib.ipynb        99-DA_Pandas_Solutions.ipynb\n",
      "04-DA_Numpy_indexing.ipynb          My_first_plot.png\n",
      "05-DA_Numpy_combining_arrays.ipynb  SNSF_data.ipynb\n",
      "06-DA_Pandas_introduction.ipynb     Untitled.ipynb\n",
      "07-DA_Pandas_structures.ipynb       \u001b[34m__pycache__\u001b[m\u001b[m/\n",
      "08-DA_Pandas_import.ipynb           ipyleaflet.ipynb\n",
      "09-DA_Pandas_operations.ipynb       multiple_arrays.npz\n",
      "10-DA_Pandas_combine.ipynb          my_saved_array.npy\n",
      "11-DA_Pandas_splitting.ipynb        \u001b[34mraw.githubusercontent.com\u001b[m\u001b[m/\n",
      "12-DA_Pandas_plotting.ipynb         svg.py\n",
      "13-DA_Pandas_ML.ipynb               \u001b[34munused\u001b[m\u001b[m/\n",
      "98-DA_Numpy_Exercises.ipynb\n"
     ]
    }
   ],
   "source": [
    "ls"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that this array is saved on disk, we can load it again using ```np.load```:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 5.41052227, 11.78370736,  9.22402365,  9.91645679,  9.48495895],\n",
       "       [10.10853493,  8.75839699,  8.26026504, 12.51736441,  9.80407577],\n",
       "       [10.09084097,  7.27962072, 11.05963249, 14.37978527,  9.00654627],\n",
       "       [ 6.01521954, 10.25115807, 10.28647927, 10.12389832,  8.91184397]])"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "new_array = np.load('my_saved_array.npy')\n",
    "new_array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you have several arrays that belong together, you can also save them in a single file using ```np.savez``` in ```npz``` format. Let's create a second array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[14.57759687,  7.62340049]])"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array_to_save2 = np.random.normal(10, 2, (1,2))\n",
    "array_to_save2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.savez('multiple_arrays.npz', array_to_save=array_to_save, array_to_save2=array_to_save2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "01-DA_Numpy_arrays_creation.ipynb   98-DA_Numpy_Solutions.ipynb\n",
      "02-DA_Numpy_array_maths.ipynb       99-DA_Pandas_Exercises.ipynb\n",
      "03-DA_Numpy_matplotlib.ipynb        99-DA_Pandas_Solutions.ipynb\n",
      "04-DA_Numpy_indexing.ipynb          My_first_plot.png\n",
      "05-DA_Numpy_combining_arrays.ipynb  SNSF_data.ipynb\n",
      "06-DA_Pandas_introduction.ipynb     Untitled.ipynb\n",
      "07-DA_Pandas_structures.ipynb       \u001b[34m__pycache__\u001b[m\u001b[m/\n",
      "08-DA_Pandas_import.ipynb           ipyleaflet.ipynb\n",
      "09-DA_Pandas_operations.ipynb       multiple_arrays.npz\n",
      "10-DA_Pandas_combine.ipynb          my_saved_array.npy\n",
      "11-DA_Pandas_splitting.ipynb        \u001b[34mraw.githubusercontent.com\u001b[m\u001b[m/\n",
      "12-DA_Pandas_plotting.ipynb         svg.py\n",
      "13-DA_Pandas_ML.ipynb               \u001b[34munused\u001b[m\u001b[m/\n",
      "98-DA_Numpy_Exercises.ipynb\n"
     ]
    }
   ],
   "source": [
    "ls"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And when we load it again:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.lib.npyio.NpzFile"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "load_multiple = np.load('multiple_arrays.npz')\n",
    "type(load_multiple)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We get here an ```NpzFile``` *object* from which we can read our data. Note that when we load an ```npz``` file, it is only loaded *lazily*, i.e. data are not actually read, but the content is parsed. This is very useful if you need to store large amounts of data but don't always need to re-load all of them. We can use methods to actually access the data:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['array_to_save', 'array_to_save2']"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "load_multiple.files"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[14.57759687,  7.62340049]])"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "load_multiple.get('array_to_save2')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.3.2 Importing data as arrays\n",
    "\n",
    "Images are a typical example of data that are array-like (matrix of pixels) and that can be imported directly as arrays. Of course, each domain will have it's own *importing libraries*. For example in the area of imaging, the scikit-image package is one of the main libraries, and it offers and importer of images as arrays which works both with local files and web addresses:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "import skimage.io\n",
    "\n",
    "image = skimage.io.imread('https://upload.wikimedia.org/wikipedia/commons/f/fd/%27%C3%9Cbermut_Exub%C3%A9rance%27_by_Paul_Klee%2C_1939.jpg')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can briefly explore that image:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.ndarray"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(image)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('uint8')"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "image.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(584, 756, 3)"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "image.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We see that we have an array of integeres with 3 dimensions. Since we imported a jpg image, we know that the thrid dimension corresponds to three color channels Red, Green, Blue (RGB)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also read regular CSV files directly as Numpy arrays. This is more commonly done using Pandas, so we don't spend much time on this, but here is an example on importing data from the web:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "oilprice = np.loadtxt('https://raw.githubusercontent.com/guiwitz/Rdatasets/master/csv/quantreg/gasprice.csv',\n",
    "          delimiter=',', usecols=range(2,3), skiprows=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([126.6, 127.2, 132.1, 133.3, 133.9, 134.5, 133.9, 133.4, 132.8,\n",
       "       132.3, 131.1, 134.1, 119.2, 116.8, 113.9, 110.6, 107.8, 105.4,\n",
       "       102.5, 104.5, 104.3, 104.7, 105.2, 106.6, 106.9, 109. , 110.4,\n",
       "       111.3, 112.1, 112.9, 114. , 113.8, 113.5, 112.6, 111.4, 110.4,\n",
       "       109.8, 109.4, 109.1, 109.1, 109.9, 111.2, 112.4, 112.4, 112.7,\n",
       "       112. , 111. , 109.7, 109.2, 108.9, 108.4, 108.8, 109.1, 109.1,\n",
       "       110.2, 110.4, 109.9, 109.9, 109.1, 107.5, 106.3, 105.3, 104.2,\n",
       "       102.6, 101.4, 100.6,  99.5, 100.4, 101.1, 101.4, 101.2, 101.3,\n",
       "       101. , 101.5, 101.3, 102.6, 105.1, 105.8, 107.2, 108.9, 110.2,\n",
       "       111.8, 112. , 112.8, 114.3, 115.1, 115.3, 114.9, 114.7, 113.9,\n",
       "       113.2, 112.8, 112.6, 112.3, 111.6, 112.3, 112.1, 112.1, 112.4,\n",
       "       112.3, 111.8, 111.5, 111.5, 111.3, 111.3, 112. , 112. , 111.2,\n",
       "       110.6, 109.8, 108.9, 107.8, 107.4, 106.9, 106.5, 106.6, 106.1,\n",
       "       105.5, 105.5, 106.2, 105.3, 104.7, 104.2, 104.8, 105.8, 105.6,\n",
       "       105.7, 106.8, 107.9, 107.9, 108.6, 108.6, 109.7, 110.6, 110.6,\n",
       "       110.7, 110.4, 110.1, 109.5, 108.9, 108.6, 108.1, 107.5, 106.9,\n",
       "       106.2, 106. , 105.9, 106.5, 106.2, 105.5, 105.1, 104.5, 104.7,\n",
       "       109.2, 109. , 109.3, 109.2, 108.4, 107.5, 106.4, 105.8, 105.1,\n",
       "       103.6, 101.8, 100.3,  99.9,  99.2,  99.5, 100.1,  99.9, 100.5,\n",
       "       100.7, 101.6, 100.9, 100.4, 100.7, 100.5, 100.7, 101.2, 101.1,\n",
       "       102.8, 103.3, 103.7, 104. , 104.5, 104.6, 105. , 105.6, 106.5,\n",
       "       107.3, 107.9, 109.5, 109.7, 110.3, 110.9, 111.4, 113. , 115.7,\n",
       "       116.1, 116.5, 116.1, 115.6, 115. , 114. , 112.9, 112. , 111.4,\n",
       "       110.6, 110.7, 112.1, 112.3, 112.2, 111.3, 108.2, 107.5, 106.4,\n",
       "       105.6, 104.4, 106.3, 107. , 106.2, 106.8, 106.8, 106.2, 105.8,\n",
       "       105.2, 106. , 106.3, 105.6, 105.5, 106.3, 107.7, 109.4, 111. ,\n",
       "       113.3, 114.1, 116.4, 117.3, 119.1, 119.3, 119.4, 119. , 118.3,\n",
       "       117.7, 116.9, 115.9, 114.8, 113.8, 112.6, 112.4, 112.1, 112.2,\n",
       "       111.3, 111.1, 110.7, 110.6, 110.6, 110. , 109.2, 108.1, 107.3,\n",
       "       106.2, 106. , 105.9, 105.6, 105.7, 105.8, 105.7, 107.2, 107.5,\n",
       "       107.7, 108.6, 109.2, 108.4, 107.9, 107.6, 107.3, 107.8, 109.9,\n",
       "       111.5, 111.6, 112.8, 115.8, 117.2, 119.5, 123.4, 124.3, 125.7,\n",
       "       125.9, 126.2, 126.9, 126. , 125.2, 124.7, 124.1, 123. , 121.9,\n",
       "       121.7, 121.5, 121.5, 120.9, 119.9, 119.6, 119.9, 120.1, 119.3,\n",
       "       120.1, 120.3, 120.3, 119.9, 119.1, 120.3, 120.5, 121.7, 122.5,\n",
       "       122.9, 123.8, 124.6, 124.2, 124.1, 123.3, 122.7, 122.4, 122. ,\n",
       "       123.5, 123.6, 123.2, 123. , 122.7, 122. , 121.7, 120.8, 119.9,\n",
       "       119.1, 119.6, 119.1, 119.2, 118.7, 118.8, 118.5, 118.2, 118.2,\n",
       "       119.5, 120.4, 120.6, 119.8, 118.9, 117.9, 117.1, 116.9, 116.5,\n",
       "       117. , 116.4, 118.5, 121.9, 121.8, 123. , 122.9, 122.7, 121.9,\n",
       "       120.8, 119.5, 119.5, 118.7, 117.8, 116.8, 116.3, 116.4, 115.6,\n",
       "       115. , 114. , 112.8, 111.8, 110.8, 109.9, 108.9, 108.3, 107.2,\n",
       "       105.5, 105.1, 104.5, 103.2, 103.8, 102.5, 101.7, 100.6,  99.8,\n",
       "       102.6, 102.3, 101.8, 102.1, 103.2, 103.8, 105.2, 105.5, 105.2,\n",
       "       104.7, 106. , 104.9, 104.1, 104.2, 104.1, 103.7, 104.4, 103.5,\n",
       "       102.3, 101.8, 101.1, 100.4,  99.8,  99.1,  98.7,  99.9,  99.9,\n",
       "       100.6, 101. , 100.7, 100.1,  99.7,  99.4,  98.1,  97.1,  95.4,\n",
       "        93.3,  92.3,  92.1,  91.4,  91.3,  92. ,  92.1,  91.3,  90.8,\n",
       "        90.7,  89.9,  88.5,  89.1,  90. ,  95.8,  99.9, 105.5, 108.7,\n",
       "       110.7, 110.3, 109.9, 110.7, 110.9, 111.2, 110.1, 108.8, 109.2,\n",
       "       108.8, 110.5, 109.5, 111. , 112.3, 114.8, 117.2, 117.2, 118.3,\n",
       "       121.4, 121.2, 121.4, 122.3, 123.4, 125.2, 124.8, 124.2, 123.4,\n",
       "       122. , 122.5, 121.8, 122.2, 124. , 125.8, 126.2, 126. , 126.3,\n",
       "       125.7, 126.3, 126. , 125.2, 126.8, 130.7, 130.7, 131.9, 135. ,\n",
       "       140. , 141.3, 149. , 151.1, 150.8, 148.4, 147.8, 144.7, 141.5,\n",
       "       140.6, 138.6, 142.7, 146.6, 149.4, 150.9, 153.5, 160.7, 166.4,\n",
       "       164.1, 160.6, 157.1, 152.1, 149.9, 144.7, 143.7, 142. , 144.4,\n",
       "       145.6, 150.2, 153.5, 153.9, 152.5, 149.8, 147.3, 151.6, 153.2,\n",
       "       152.3, 150.2, 150.1, 148.7, 148.9, 146.4, 142.5, 139.6, 138.8,\n",
       "       137.7, 140. , 145.8, 145.6, 144.6, 142.6, 146. , 142.9, 141. ,\n",
       "       139.3, 138.7, 137.7, 137.9, 141.1, 146.9, 153.5, 158.6, 158.5,\n",
       "       165.9, 166.3, 163.7, 165.6, 163. , 158. , 152.6, 145.4, 138.4,\n",
       "       135. , 133. , 131.8, 131.9, 131.9, 134.7, 139.9, 148. , 153.8,\n",
       "       151.1, 151.6, 146. , 138.1, 131. , 126.4, 122.1, 119.3, 117. ,\n",
       "       114.7, 114. , 109.7, 108.4, 107.5, 104.2, 106.3, 109.6, 110.9,\n",
       "       109.9, 108.7, 108.1, 109.8, 108.5, 108.9, 108.7, 111.8, 119.4,\n",
       "       126.2, 130.8, 133.9, 138.2, 136.8, 136.7, 135.3, 135.6, 134.9,\n",
       "       136. , 134.8, 135.3, 133.2, 133.5, 134.2, 135.7, 134.5, 136.1,\n",
       "       138.1, 137.6, 135.5, 135.5, 135.7, 136.5, 135.3, 135.5, 136.7,\n",
       "       135.7, 138.5, 141.6, 142.2, 144.3, 142.7, 142.7, 140.6, 137. ,\n",
       "       133.6, 131.6, 131.6, 132.2, 137.1, 141.7, 141.2, 142.3, 142.2,\n",
       "       143.7, 149.9, 158.2, 163. , 161.7, 164.1, 166.3, 167.3, 162.6,\n",
       "       157.7, 155.7, 152.1, 150.4, 148.6, 144.1, 142.7, 144.4, 143.9,\n",
       "       142.8, 145.6, 148. , 145.1, 144.3, 144.8, 148.9, 149.6, 148.8,\n",
       "       151.6, 155. , 159.4, 169.3, 168.8, 165.3, 163.6, 158. , 152.4,\n",
       "       151.1, 151.5, 152.7, 149.9, 149.4, 146.4, 145.9, 147.8, 145.4,\n",
       "       144.1, 143.3, 145.9, 145.4, 149.2, 154.4, 157.9, 160.4, 159.1,\n",
       "       160.9, 161.7])"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "oilprice"
   ]
  },
  {
   "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.8.2"
  },
  "nteract": {
   "version": "0.23.1"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": false,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}