{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "The cell below downloads data needed for the notebook to run. You **must** execute this cell to continue." ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/html": [ "\n", "\n", "\n", "\n", "\n", "" ], "text/plain": [ "" ] }, "execution_count": 1, "metadata": {}, "output_type": "execute_result" } ], "source": [ "!git clone https://github.com/StuartLittlefair/python-bootcamp.git\n", "!cp -r python-bootcamp/pybootcamp-part2/code .\n", "!cp -r python-bootcamp/pybootcamp-part2/data ." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Analysing Star Data" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "
\n", "

Learning Objectives

\n", "
\n", "
\n", "\n", "> * Explain what a library is, and what libraries are used for.\n", "* Load a Python library and use the things it contains. \n", "* Read tabular data from a file into a program. \n", "* Assign values to variables.\n", "* Select individual values and subsections from data. \n", "* Perform operations on arrays of data. \n", "* Display simple graphs. \n", "\n", "---\n", "\n", "Words are useful, but what’s more useful are the sentences and stories we build with them. Similarly, while a lot of powerful tools are built into languages like Python, even more live in the libraries they are used to build.\n", "\n", "In order to load our star data, we need to import a library called NumPy. In general you should use this library if you want to do fancy things with numbers, especially if you have matrices or arrays. We can load NumPy using:" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "collapsed": true, "jupyter": { "outputs_hidden": true } }, "outputs": [], "source": [ "import numpy" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Importing a library is like getting a piece of lab equipment out of a storage locker and setting it up on the bench. Once you’ve loaded the library, we can ask the library to read our data file for us: " ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "text/plain": [ "array([[ 18.82835767, 18.68449456, 18.36846526, ..., 22.74609287,\n", " 21.59114633, 22.94081404],\n", " [ 18.44871905, 19.02446975, 20.04453884, ..., 23.23142209,\n", " 21.62410045, 23.72676083],\n", " [ 17.59471749, 17.86504252, 19.04176145, ..., 21.65369823,\n", " 22.58501188, 22.75590757],\n", " ..., \n", " [ 19.14663683, 17.5576204 , 17.7209417 , ..., 23.08328494,\n", " 23.2540362 , 22.54150028],\n", " [ 17.91820205, 17.51246092, 19.22285053, ..., 22.40570422,\n", " 22.20877154, 23.69307697],\n", " [ 18.99298186, 18.17059033, 20.43678823, ..., 23.82297922,\n", " 22.80203104, 23.13107049]])" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "numpy.loadtxt(fname='data/star_data_01.csv', delimiter=',')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The expression `numpy.loadtxt(...)` is a [function call](https://sheffield-mps.github.io/MPS227/bootcamp/reference/#function-call)\n", "that asks Python to run the function `loadtxt` that belongs to the `numpy` library.\n", "This [dotted notation](https://sheffield-mps.github.io/MPS227/bootcamp/reference/#dotted-notation) is used everywhere in Python\n", "to refer to the parts of things as `thing.component`.\n", "\n", "`numpy.loadtxt` has two [parameters](https://sheffield-mps.github.io/MPS227/bootcamp/reference/#parameter): the name of the file we want to read, and the [delimiter](https://sheffield-mps.github.io/MPS227/bootcamp/reference/#delimiter) that separates values on a line. These both need to be character strings (or [strings](https://sheffield-mps.github.io/MPS227/bootcamp/reference/#string) for short), so we put them in quotes.\n", "\n", "When we are finished typing and press Shift+Enter, the notebook runs our command. Since we haven't told it to do anything else with the function's output, the notebook displays it.\n", "In this case, that output is the data we just loaded. By default, only a few rows and columns are shown (with `...` to omit elements when displaying big arrays).\n", "\n", "Our call to `numpy.loadtxt` read our file, but didn't save the data in memory. To do that,\n", "we need to [assign](https://sheffield-mps.github.io/MPS227/bootcamp/reference/#assignment) the array to a [variable](https://sheffield-mps.github.io/MPS227/bootcamp/reference/#variable). A variable is just a name for a value, such as `x`, `current_temperature`, or `subject_id`.\n", "\n", "\n", "## Variables\n", "\n", "Python's variables must begin with a letter and are [case sensitive](https://sheffield-mps.github.io/MPS227/bootcamp/reference/#case-sensitive). We can create a new variable by assigning a value to it using `=`.\n", "As an illustration, let's step back and instead of considering a table of data, consider the simplest \"collection\" of data, a single value. The line below assigns the value `55` to a variable `weight_kg`:" ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "collapsed": true, "jupyter": { "outputs_hidden": true } }, "outputs": [], "source": [ "weight_kg = 55" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This statement says to the computer \"put the value of `55` inside the box labelled `weight_kg`\". This is useful because we can use it later in calculations. For example: once a variable has a value, we can print it to the screen: " ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "55\n" ] } ], "source": [ "print(weight_kg)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "and do arithmetic with it: " ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "weight in pounds 121.00000000000001\n" ] } ], "source": [ "print('weight in pounds', 2.2*weight_kg)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can also change a variable’s value by assigning it a new one: " ] }, { "cell_type": "code", "execution_count": 7, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "weight in kilograms is now: 57.5\n" ] } ], "source": [ "weight_kg = 57.5\n", "print ('weight in kilograms is now:', weight_kg)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "As the example above shows, we can print several things at once by separating them with commas.\n", "\n", "We should imagine the variable as a box to store something in the computer's memory. The name of the variable is the label attached to the box, like a sticky note.\n", "\n", "![Figure: Variables as sticky note labels on boxes](https://sheffield-mps.github.io/MPS227/bootcamp/images/python-sticky-note-variables-01.svg)\n", "\n", "\n", "This means that assigning a value to one variable does *not* change the values of other variables. For example, let’s store the subject’s weight in pounds in a variable:" ] }, { "cell_type": "code", "execution_count": 8, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "weight in kilograms: 57.5 and in pounds: 126.50000000000001\n" ] } ], "source": [ "weight_lb = 2.2 * weight_kg\n", "print ('weight in kilograms:', weight_kg, 'and in pounds:', weight_lb)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "![Figure: Creating another variable](https://sheffield-mps.github.io/MPS227/bootcamp/images/python-sticky-note-variables-02.svg)\n", "\n", "and then change `weight_kg`" ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "weight in kilograms is now: 100.0 and weight in pounds is still: 126.50000000000001\n" ] } ], "source": [ "weight_kg = 100.0\n", "print ('weight in kilograms is now:', weight_kg, 'and weight in pounds is still:', weight_lb)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "![Figure: Updating a variable](https://sheffield-mps.github.io/MPS227/bootcamp/images/python-sticky-note-variables-03.svg)\n", "\n", "
Figure: Updating a variable
\n", " \n", "Since `weight_lb` doesn’t “remember” where its value came from, it isn’t \n", "automatically updated when `weight_kg` changes. This is different from the way \n", "spreadsheets work.\n", "\n", "The statement `weight_kg=100.0` is not a mathematical equation. It's an instruction to the computer which means \"take the value on the RHS (`100.0`), and store it in a variable with the name on the LHS (`weight_kg`)\". The RHS is calculated first, then the result is put in the variable named on the left. Therefore, the following statement makes perfect sense in Python!" ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "weight in kilograms is now: 95.0\n" ] } ], "source": [ "weight_kg = weight_kg - 5\n", "print ('weight in kilograms is now:', weight_kg)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Just as we can assign a single value to a variable, we can also assign an array of values to a variable using the same syntax. Let’s re-run `numpy.loadtxt` and save its result:" ] }, { "cell_type": "code", "execution_count": 11, "metadata": { "collapsed": true, "jupyter": { "outputs_hidden": true } }, "outputs": [], "source": [ "data = numpy.loadtxt(fname='data/star_data_01.csv', delimiter=',')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This statement doesn’t produce any output because assignment doesn’t display anything. If we want to check that our data has been loaded, we can print the variable’s value:" ] }, { "cell_type": "code", "execution_count": 12, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[[ 18.82835767 18.68449456 18.36846526 ..., 22.74609287 21.59114633\n", " 22.94081404]\n", " [ 18.44871905 19.02446975 20.04453884 ..., 23.23142209 21.62410045\n", " 23.72676083]\n", " [ 17.59471749 17.86504252 19.04176145 ..., 21.65369823 22.58501188\n", " 22.75590757]\n", " ..., \n", " [ 19.14663683 17.5576204 17.7209417 ..., 23.08328494 23.2540362\n", " 22.54150028]\n", " [ 17.91820205 17.51246092 19.22285053 ..., 22.40570422 22.20877154\n", " 23.69307697]\n", " [ 18.99298186 18.17059033 20.43678823 ..., 23.82297922 22.80203104\n", " 23.13107049]]\n" ] } ], "source": [ "print(data)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now that our data is in memory, we can start doing things with it. First,\n", "let's ask what [type](https://sheffield-mps.github.io/MPS227/bootcamp/reference/#type) of thing `data` refers to:" ] }, { "cell_type": "code", "execution_count": 13, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n" ] } ], "source": [ "print( type(data) )" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The output tells us that `data` currently refers to an N-dimensional array created by the NumPy library. These data corresponds to star's brightness over time. The rows are the individual stars and the columns are their brightness measurements.\n", "\n", "We can see what its [shape](https://sheffield-mps.github.io/MPS227/bootcamp/reference/#shape) is like this:" ] }, { "cell_type": "code", "execution_count": 14, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "(20, 101)\n" ] } ], "source": [ "print( data.shape )" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This tells us that `data` has 20 rows and 101 columns. \n", "\n", "When we created the\n", "variable `data` to store our star data, we didn't just create the array, we also created information about the array, called [members](https://sheffield-mps.github.io/MPS227/bootcamp/reference/#member) or attributes. This extra information describes `data` in the same way an adjective describes a noun.\n", "\n", "`data.shape` is an attribute of `data` which described the dimensions of `data`. We use the same dotted notation for the attributes of variables that we use for the functions in libraries because they have the same part-and-whole relationship.\n", "\n", "If we want to get a single number from the array, we must provide an [index](https://sheffield-mps.github.io/MPS227/bootcamp/reference/#index) in square brackets, just as we do in math:" ] }, { "cell_type": "code", "execution_count": 15, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "first value in data: 18.8283576684\n" ] } ], "source": [ "print('first value in data:', data[0,0])" ] }, { "cell_type": "code", "execution_count": 16, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "middle value in data: 22.9296967381\n" ] } ], "source": [ "print('middle value in data:', data[10,50])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The expression `data[10, 50]` may not surprise you if you've done some programming before,\n", "but `data[0, 0]` might. Programming languages like Fortran and MATLAB start counting at 1,\n", "because that's what human beings have done for thousands of years. Languages in the C family (including C++, Java, Perl, and Python) count from 0 because that's simpler for computers to do.\n", "\n", "As a result, if we have an M$\\times$N array in Python, its indices go from 0 to M-1 on the first axis and 0 to N-1 on the second. It takes a bit of getting used to, but one way to remember the rule is that the index is how many steps we have to take from the start to get the item we want." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "
\n", "

In the corner

\n", "
\n", "
\n", "\n", "> What may also surprise you is that when Python displays an array,\n", "> it shows the element with index `[0, 0]` in the upper left corner\n", "> rather than the lower left.\n", "> This is consistent with the way mathematicians draw matrices,\n", "> but different from the Cartesian coordinates.\n", "> The indices are (row, column) instead of (column, row) for the same reason,\n", "> which can be confusing when plotting data." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "An index like `[10, 50]` selects a single element of an array,\n", "but we can select whole sections as well.\n", "For example,\n", "we can select the first five measurements (columns) of brightness\n", "for the first four stars (rows) like this:" ] }, { "cell_type": "code", "execution_count": 17, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[[ 18.82835767 18.68449456 18.36846526 19.58984702 20.03332339]\n", " [ 18.44871905 19.02446975 20.04453884 18.37560557 20.13318031]\n", " [ 17.59471749 17.86504252 19.04176145 18.6676958 19.09431148]\n", " [ 18.1584409 19.6630396 19.33900909 19.53610008 19.49240261]]\n" ] } ], "source": [ "print( data[0:4, 0:5] )" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The [slice](https://sheffield-mps.github.io/MPS227/bootcamp/reference/#slice) `0:4` means, \"Start at index 0 and go up to, but not including, index 4.\" Again, the up-to-but-not-including takes a bit of getting used to, but the rule is that the difference between the upper and lower bounds is the number of values in the slice.\n", "\n", "We don't have to start slices at 0:" ] }, { "cell_type": "code", "execution_count": 18, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[[ 18.54685036 17.38553589 18.62617314 18.97304937 18.46415131]\n", " [ 18.67357342 18.41288864 18.79151865 18.18382694 19.81400528]\n", " [ 17.85769513 17.60871584 17.3801041 19.27209263 19.8817563 ]\n", " [ 18.93911752 18.38229775 18.65671745 19.50607296 18.65884615]\n", " [ 18.01124928 17.54423449 19.16271396 18.79464109 19.12882441]]\n" ] } ], "source": [ "print (data[5:10, 0:5])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We also don't have to include the upper and lower bound on the slice. If we don't include the lower bound, Python uses 0 by default;\n", "if we don't include the upper, the slice runs to the end of the axis,\n", "and if we don't include either (i.e., if we just use ':' on its own),\n", "the slice includes everything:" ] }, { "cell_type": "code", "execution_count": 19, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "small is:\n", "[[ 22.74609287 21.59114633 22.94081404]\n", " [ 23.23142209 21.62410045 23.72676083]\n", " [ 21.65369823 22.58501188 22.75590757]]\n" ] } ], "source": [ "small = data[:3, 98:]\n", "print ('small is:')\n", "print (small)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Arrays also know how to perform common mathematical operations on their values. The simplest operations with data are arithmetic: add, subtract, multiply, and divide. When you do such operations on arrays, the operation is done on each individual element of the array.\n", "\n", "Thus:" ] }, { "cell_type": "code", "execution_count": 20, "metadata": { "collapsed": true, "jupyter": { "outputs_hidden": true } }, "outputs": [], "source": [ "doubledata = data * 2.0" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "will create a new array `doubledata` whose elements have the value of two times the value of the corresponding elements in `data`:" ] }, { "cell_type": "code", "execution_count": 21, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "original:\n", "[[ 22.74609287 21.59114633 22.94081404]\n", " [ 23.23142209 21.62410045 23.72676083]\n", " [ 21.65369823 22.58501188 22.75590757]]\n", "doubledata:\n", "[[ 45.49218574 43.18229266 45.88162809]\n", " [ 46.46284418 43.2482009 47.45352166]\n", " [ 43.30739646 45.17002377 45.51181515]]\n" ] } ], "source": [ "print ('original:')\n", "print (data[:3,98:])\n", "print ('doubledata:')\n", "print (doubledata[:3,98:])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "If, instead of taking an array and doing arithmetic with a single value (as above) you did the arithmetic operation with another array of the same shape, the operation will be done on corresponding elements of the two arrays.\n", "\n", "Thus:" ] }, { "cell_type": "code", "execution_count": 22, "metadata": { "collapsed": true, "jupyter": { "outputs_hidden": true } }, "outputs": [], "source": [ "tripledata = data + doubledata" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "will give you an array where `tripledata[0,0]` will equal `doubledata[0,0]` plus `data[0,0]`, and so on for all other elements of the arrays." ] }, { "cell_type": "code", "execution_count": 23, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "tripledata:\n", "[[ 68.2382786 64.77343899 68.82244213]\n", " [ 69.69426627 64.87230134 71.18028248]\n", " [ 64.96109469 67.75503565 68.26772272]]\n" ] } ], "source": [ "print ('tripledata:')\n", "print (tripledata[:3,98:])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Often, we want to do more than add, subtract, multiply, and divide values of data.\n", "Arrays also know how to do more complex operations on their values.\n", "If we want to find the average brightness for all stars at all times,\n", "for example, we can just ask the array for its mean value" ] }, { "cell_type": "code", "execution_count": 24, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "22.5002003719\n" ] } ], "source": [ "print (data.mean())" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "`mean` is a [method](https://sheffield-mps.github.io/MPS227/bootcamp/reference/#method) of the array, i.e., a function that belongs to it in the same way that the member `shape` does. If variables are nouns, methods are verbs: they are what the thing in question knows how to do. We need empty parentheses for `data.mean()`,\n", "even when we're not passing in any parameters, to tell Python to go and do something for us. `data.shape` doesn't need `()` because it is just a description but `data.mean()` requires the `()` because it is an action. This will become clearer when we cover functions later.\n", "\n", "Numpy arrays have lots of useful methods:" ] }, { "cell_type": "code", "execution_count": 25, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "maximum brightness: 26.9747210312\n", "minimum brightness: 16.4477700722\n", "standard deviation: 1.71095670561\n" ] } ], "source": [ "print ('maximum brightness:', data.max())\n", "print ('minimum brightness:', data.min())\n", "print ('standard deviation:', data.std())" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "When analyzing data, though, we often want to look at partial statistics, such as the maximum brightness per star or the average brightness per day. One way to do this is to create a new temporary array of the data we want, then ask it to do the calculation:" ] }, { "cell_type": "code", "execution_count": 26, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "maximum brightness for star 0: 26.0072998375\n" ] } ], "source": [ "star_0 = data[0,:] # 0 on the first axis (row), everything on the second (column)\n", "print ('maximum brightness for star 0:', star_0.max())" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We don’t actually need to store the row in a variable of its own. Instead, we can combine the selection and the method call:" ] }, { "cell_type": "code", "execution_count": 27, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "mean brightness for star 2: 22.4261580993\n" ] } ], "source": [ "print ('mean brightness for star 2:', data[2,:].mean())" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "What if we need the maximum brightness for all stars (as in the next diagram on the left), or the average at each time (as in the diagram on the right)? As the diagram below shows, we want to perform the operation across an axis: \n", "\n", "\n", "
Figure: Operations across axes
" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "To support this, most array methods allow us to specify the axis we want to work on. If we ask for the average across axis 0 (rows in our 2D example), we get:" ] }, { "cell_type": "code", "execution_count": 28, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[ 18.09248632 18.35365907 18.85192129 18.71415503 19.37229196\n", " 19.52248221 19.67364454 20.29042241 20.4574627 20.31294399\n", " 20.57276817 20.81105239 21.22518779 21.33178541 21.27505307\n", " 21.18294918 21.55675437 21.40098742 21.51005242 21.79133686\n", " 21.71258645 21.95332038 22.1794417 21.76243396 21.90496963\n", " 22.30208365 22.00749989 21.8791797 21.86355606 21.85633962\n", " 21.89303383 21.44298308 21.86877405 21.85459712 22.06337395\n", " 21.57714292 21.49346007 21.31626957 21.40087753 21.2563051\n", " 21.21483226 21.50582255 21.25908068 22.17820386 22.26884077\n", " 23.01761462 23.31593697 23.78381811 24.08434858 24.18429216\n", " 24.04024153 23.82691284 24.10082433 24.13538645 23.97002714\n", " 24.02488626 24.34074191 24.338722 24.13667692 24.13243851\n", " 24.09342369 24.82766196 24.37718333 24.77509604 24.77981012\n", " 24.72882825 24.25050139 24.30764042 24.39156066 24.23850235\n", " 24.1826964 24.13769011 24.17456216 23.77952067 23.77599953\n", " 23.52540135 23.54859622 23.47995816 23.30139227 23.1124789\n", " 23.25623871 22.86721499 22.68945751 22.56457647 22.37963091\n", " 22.37735687 22.84335853 22.6586068 22.63715706 22.88578965\n", " 22.85114912 23.08154727 23.27159687 23.56745498 23.29833557\n", " 23.24320422 23.33254035 22.82910288 23.16761664 22.49790649\n", " 22.68461845]\n" ] } ], "source": [ "print (data.mean(axis=0))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "As a quick check, we can ask this array what its shape is:" ] }, { "cell_type": "code", "execution_count": 29, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "(101,)\n" ] } ], "source": [ "print ( data.mean(axis=0).shape )" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The expression `(101,)` tells us we have an N$\\times$1 vector,\n", "so this is the average brightness as a function of time for all stars.\n", "\n", "## Visualising Data\n", "\n", "The mathematician Richard Hamming once said, \"The purpose of computing is insight, not numbers,\" and the best way to develop insight is often to visualize data. Visualization deserves an entire lecture (or course) of its own, but we can explore a few features of Python's `matplotlib` library here. While there is no \"official\" plotting library, this package is the de facto standard. First, we will import the `pyplot` module from `matplotlib` and use two of its functions to create and display a heat map of our data:" ] }, { "cell_type": "code", "execution_count": 30, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "import matplotlib.pyplot \n", "%matplotlib inline \n", "image = matplotlib.pyplot.imshow(data) \n", "matplotlib.pyplot.xlabel('Time')\n", "matplotlib.pyplot.ylabel('Star number')\n", "matplotlib.pyplot.show(image)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Dark regions in this heat map are low values, while light regions show high values. As we can see, most stars in our data show roughly the same trends with time. " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "
\n", "

Some IPython 'magic'

\n", "
\n", "
\n", "\n", "> If you’re using an IPython / Jupyter notebook, you’ll need to execute the following command in order for your matplotlib images to appear in the notebook when ```show()``` is called:\n", "\n", "> ```python\n", "> % matplotlib inline\n", "> ```\n", "\n", "> The % indicates an IPython magic function - a function that is only valid within the notebook environment. Note that you only have to execute this function once per notebook.\n", "\n", "---" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Let's take a look at the average brightness of a star over time:" ] }, { "cell_type": "code", "execution_count": 31, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "ave_brightness = data.mean(axis=0)\n", "ave_plot = matplotlib.pyplot.plot(ave_brightness)\n", "matplotlib.pyplot.xlabel('Time')\n", "matplotlib.pyplot.ylabel('Brightness')\n", "matplotlib.pyplot.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Here, we have put the average across all stars in the variable `ave_brightness`, then asked `matplotlib.pyplot` to create and display a line graph of those values.\n", "\n", "Since most stars follow the same trend, these changes in brightness can't be intrinsic to the stars themselves. They are probably changes due to clouds absorbing some of the light from all of the stars we see in our data.\n", "\n", "We could see if any of the stars deviate from this common trend by dividing the brightness of each star the average brightness of all stars:" ] }, { "cell_type": "code", "execution_count": 32, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "processed_data = data / ave_brightness\n", "image = matplotlib.pyplot.imshow(processed_data) \n", "matplotlib.pyplot.show(image) " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "It looks like all of our stars just follow this general trend, since there is nothing but random noise left in the processed data. If any of our stars were varying, it should stand out in this plot. \n", "\n", "Interestingly, it looks like all of our stars show roughly the same amount of noise - a fact that can be confirmed using `numpy` and an extra plot." ] }, { "cell_type": "code", "execution_count": 33, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Std. deviation of star 0 is 0.0321183778763\n", "Std. deviation of star 1 is 0.0320419928419\n", "Std. deviation of star 2 is 0.031276317636\n" ] }, { "data": { "image/png": "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", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "print(\"Std. deviation of star 0 is \", processed_data[0,:].std())\n", "print(\"Std. deviation of star 1 is \", processed_data[1,:].std())\n", "print(\"Std. deviation of star 2 is \", processed_data[2,:].std())\n", "matplotlib.pyplot.plot(processed_data[0,:])\n", "matplotlib.pyplot.plot(processed_data[1,:])\n", "matplotlib.pyplot.plot(processed_data[2,:])\n", "matplotlib.pyplot.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "
\n", "

Check your understanding

\n", "
\n", "
\n", "\n", "> What variables refer to what values after each statement in the following program? Check your answer with the person next to you, then run the program in the cell below and see if you were correct.\n", "```python\n", "mass = 47.5\n", "age = 122\n", "mass = mass*2.0\n", "age = age-20\n", "```" ] }, { "cell_type": "code", "execution_count": 34, "metadata": { "collapsed": true, "jupyter": { "outputs_hidden": true } }, "outputs": [], "source": [ "# INSERT YOUR CODE HERE" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "
\n", "

Sorting out references

\n", "
\n", "
\n", "\n", "> What does the following program print out?\n", "```python\n", "first, second = 'Grace', 'Hopper'\n", "third, fourth = second, first\n", "print(third, fourth)\n", "```\n", "Run the code below and see if you were right." ] }, { "cell_type": "code", "execution_count": 35, "metadata": { "collapsed": true, "jupyter": { "outputs_hidden": true } }, "outputs": [], "source": [ "# INSERT YOUR CODE HERE" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "
\n", "

Slicing strings

\n", "
\n", "
\n", "\n", ">A section of an array is called a [slice](https://sheffield-mps.github.io/MPS227/bootcamp/reference/#slice). We can take slices of character strings as well:" ] }, { "cell_type": "code", "execution_count": 36, "metadata": { "collapsed": false, "jupyter": { "outputs_hidden": false } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "first three characters: oxy\n", "last three characters: gen\n" ] } ], "source": [ "element = 'oxygen'\n", "print ('first three characters:', element[0:3])\n", "print ('last three characters:', element[3:6])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "> What is the value of `element[:4]`?\n", "> What about `element[4:]`?\n", "> Or `element[:]`?\n", ">\n", "> What is `element[-1]`?\n", "> What is `element[-2]`?\n", "> Given those answers,\n", "> explain what `element[1:-1]` does." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "
\n", "

Make your own plot

\n", "
\n", "
\n", "\n", ">Create a plot showing the standard deviation (`numpy.std`) of each star against the star number" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel)", "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.10" } }, "nbformat": 4, "nbformat_minor": 4 }