We will use python bundled with a few key scientific libraries (Numpy, Scipy, and Matplotlib) in an installation called "Anaconda" that you can download from here. To determine whether your system has a 32-bit or 64-bit processor, see the following links: Mac Users or Windows Users.

Part II: Getting Started and Recording Your Work

After installing Anaconda, find the "Spyder" app in the installation folder or your programs menu, which will provide a nice user interface. Spyder may take a while to start up, because of all the python libraries it is loading.


The first thing to note is how the Spyder app is organized. The application includes multiple separate windows (marked with red rectangles), each of which has its own tabs (marked with green rectangles). You can change which windows you prefer to have open from the View -> Windows and Toolbars option. The default configuration has the Editor, Object inspector/Variable explorer/File explorer, and Console/History log windows open as shown above (except that the Variable explorer tab is missing in the screenshot).

The Console is where python is waiting for you to type commands, which tell it to load data, do math, plot data, etc. After every command, which looks like >>> command, you need to hit the enter key (return key), and then python may or may not give some output. The Editor allows you to write sequences of commands, which together make up a program. The History Log stores the last 100 commands you've typed into the Console. The Object inspector/Variable explorer/File explorer windows are purely informational -- if you watch what the first two display as we go through the tutorial, you'll see that they can be quite helpful.

Entering Data
Type "x=5" in the Console -- this is the command to create a variable named x and give it the value 5. If you raise the "Variable explorer" tab you will see that x has been added to the list of variables in python's memory. You can also type "print x" or even just "x" in the Console to see the value of x. Now type "y=4" and then "x+y". Notice that this last command does not create a variable, although it does produce an output from the calculation.

Arrow Keys
If you use the arrow keys in the Console, you can bring back a previous command so that you can edit and re-execute it. Go back to the command "x+y" and change it to "junk=x+y". You've now created the variable junk. What can you type to see its value in the Console?

Arrays
Python can work with arrays of numbers, such as columns of data or tables of data (rows and columns). However, by default it is set up to handle lists of any kind of data -- perhaps names or addresses, not just numbers -- so we have to use the "array" function from Numpy (numerical python) to tell python that a given set of numbers should be treated as a numerical array. Before we do this, we need to learn the syntax for calling functions from a library.

Interlude on Libraries Behind the scenes, Anaconda installs the libraries Numpy, Scipy, and Matplotlib to give you access to thousands of special functions. Every time you want to call one of these functions, you must first type the name of the library, followed by the name of the function like so "Library.Function". Furthermore, the library must have been "imported" before you type this command. The Console automatically imports Numpy, Scipy, and Matplotlib at startup, as well as the sublibrary "pyplot" from Matplotlib, and it also gives the libraries nicknames so you don't have to type the whole name out (np, sp, mpl, and plt respectively). However, you would need to do this manually in any program you wrote in the Editor window, for example by starting the program with the command "import Numpy as np". Type "scientific" into the Console to see the full list of commands executed by the Console on startup.

Interlude on Comments The # signs after each command output by "scientific" indicate comments explaining what these commands do. Comments are ignored by python and not executed. They are very useful for reminding yourself what a program is actually doing when you go back to look at it a few months after writing it.

Now back to arrays. We wish to create a numerical array, as opposed to a list of numbers. To see how these differ, first type

>>> x=np.array([1,2,3,4])
>>> y=np.array([4,0,3,2])
>>> z=x+y
>>> print z

and look at how these variables appear in the Variable explorer. Now type

>>> x=[1,2,3,4]
>>> y=[4,0,3,2]
>>> z=x+y
>>> print z

and compare. For present purposes, we are not interested in the "list" behavior of the second set of commands, but only the "array" behavior of the first set. It's also worth noting that python happily overwrites x, y, and z with no error message, even when it means changing their variable types -- this behavior is different from that of programming languages that declare variables.

When working with real data, we may have both rows and columns. For example, define "x=np.array([[1, 3] , [2, 4], [10, 11]])". The brackets within brackets imply 3 rows and 2 columns.

If you want to pick out one or more rows/columns in the array, you must use "indices" (a.k.a. "subscripts") to identify the portion of the array you want -- rows first, columns second, in square brackets. Both are numbered starting from zero. The colon ":" indicates a range, with two odd features -- first, "x:y" actually means index numbers from x to (y-1), and second, ":" by itself means all index numbers. For example, compare the results of "out1=x[1:2,1:2]" with the result of "out2=x[0,:]". In the first example the colon acts like a dash specifying a range, i.e., read "1:2" as "1 to (2-1)" which is "1 to 1" or just the single index 1. The first command says you want out1 to be restricted to row #1 (the second row) and column #1 (the second column) of "x", while the second says you want out2 to equal row 0 (the first row) of "x" with all columns. We refer to each number in an array as an element. Try to write a command to select the element of "x" in the second row, first column, and assign it to "y".

Special Arrays
Numpy's "arange" function can be used to generate a series of numbers, either in +1 increments (the default) or in increments you specify. Compare the output of "x1=np.arange(1,5)" and "x2=np.arange(1,5,2)". The final number is the increment, unless it's missing, in which case it's assumed to be 1. The first two numbers are the starting and ending points, but once again python stops one increment before the ending point, just as for subscript ranges.

The "zeros" command can also be useful to make arrays you want to fill in with nonzero values later. For example, type "newarray=np.zeros([4,3])" and "x1=np.arange(1,5)". Examine these variables dimensions under the "Size" column in the Variable explorer, or type "newarray.shape" and "x1.shape" to output their dimensions. Now type "newarray[:,1]=x1". Examine the result carefully -- why was it necessary to use subscripts on newarray before inserting x1? Try "z=newarray+x1". It gives an error -- why?

Simple Math
Although python can do advanced math, we won't need that, so you should just remember a few simple operators and functions:
+ addition
- subtraction
* multiplication
/ division
** to-the-power-of
e times 10-to-the (e.g. 2.e4 = 2 .* 10^4)
abs() absolute value
sqrt() square root
exp() e^
log() natural log or ln
log10() ordinary log (opposite of 10^)
sin() sine of angle in radians
cos() cosine of angle in radians

Note that the operators listed above do math "element-wise", meaning if you, e.g., multiply two single column arrays, the two first elements will multiply, the two second elements will multiply, the two third elements will multiply, etc. Unlike matlab, python does not treat "*" as matrix multiplication for arrays, rather as simple element-wise multiplication.

Now using parentheses and simple math, you can create your own functions. For example, suppose you'd like to define a column of data (one-dimensional array) that obeys the equation c=lambda*nu over a range of lambda from 300-700nm going up by 50nm at a time. You can type "lam=300.+np.arange(0,401,50)" first, then "nu=3.e17 / lam" (where the speed of light is 3 x 10^17 in units of nm/sec). The output should be nu in Hertz (1/sec). Notice that although the "300." was a scalar, python allows you to add it to an array (all elements) and does not complain about size mismatch. Warning: don't try to use the variable name "lambda" instead of "lam"! The word "lambda" has a special meaning in the python programming language, which we don't need to get into.

Use parentheses liberally! It is very easy to do different math than you intend. Notice that "nu=3.e17 / 300.+np.arange(0,401,50)" does not work properly, although you could write "nu=3.e17 / (300.+np.arange(0,401,50))".

Multi-Element Math
You might like to compute some overall properties of a data set. We'll save some tricks of this type for later, but try these simple ones: sum, max, min, median, mean. You can see how these functions work by creating a 3x3 array of random numbers (for this you will need a special sublibrary of Numpy called "random", so the syntax is "x=np.random.rand(3,3)") and then computing each statistic, e.g., "mean(x)".

What else is out there?
Extensive lists of additional functions available to you can be found here: Numpy, Scipy, and Matplotlib. Moreover, there are dozens of other python libraries we will not be using -- someday you may create your own library!

Logging Your Work
Now that you've seen the basics, let's start recording your work. To do this, you should paste all your successful commands from the History or Console window into the Editor window, where they will become a program (sequence of commands). Do NOT paste in the ">>>" from the Console, but please DO paste in the output from your successful commands, inserting a "#" comment character before each line of output so that python does not try to interpret the output as a command. The program file in the Editor window will initially be labeled ".temp.py" but you should save it under the new name "tutorialanswers_yournamehere.py" in a different folder that you will use for all your python files. Also put a comment at the top with your name and date, and make sure to explicitly insert the startup file commands we saw when we typed "scientific". Now you can check your answers by saving and running your program with the "save" (disk icon) and "play" (green arrow icon) buttons at the top of Spyder. You will submit your final program file as part of your homework.

At last, it's time to show off your new python skills "for the record."

(1) Using "arange", create an array called "myarray" that has the same length as the number of letters in your last name and counts up from 1.
(2) Create a second array that is the square root of the first. Call the second array "rootarray". How many elements are in "rootarray"? If it's not the same as the number of letters in your last name, you have a problem.
(3) Compute myarray divided by rootarray. You can name the result "ratio". Careful! Check that myarray has more than one element. If it doesn't have the same number of elements as the number of letters in your last name, go back and review the section on "Simple Math" above.
(4) Multiply ratio times rootarray. Does the result make sense?
(5) Add a comment to your program file to answer the question from (4), i.e. explain why the result makes sense.

The final version of your program file should contain only successful commands and their output -- please leave only your most brilliant work for the grader.

Part III: Reading and Plotting Data

First, download testdata.in into the directory where you keep your python files -- this should be the same one where you put "tutorialanswers_yournamehere.py" earlier. Reading the data is now simple: just type

data=np.loadtxt(r"XXXXtestdata.in")

where "XXXX" should be replaced with the path to your file (displayed at the top of the Editor Window if you put your program and data files in the same place as instructed). An example might be "C:\My Documents\Python Scripts\". The extra "r" in front of the path and filename is necessary to force python to interpret the information literally. Note that loadtxt *assumes* your data is in numeric form, so if there's a header with column names, you should remove that before reading.

Now, you have all your data in one array. If you want to work with different columns, it is helpful to name them and extract them from the array. For example:
temperature=data[:,0]
humidity=data[:,1]

To plot temperature vs. humidity, you can just type "plt.plot(humidity,temperature)" where the desired x-axis is listed first. This should pop up a plotting window with the data points connected by lines -- rather a mess.

To beautify this plot, we can specify the output more: "plt.plot(humidity,temperature,'b.',markersize=12)" will use blue dots with dot size 12 (most obvious colors work, e.g. r for red, g for green -- see summary here). Type this in, then look back at the plot window. Unfortunately, the mess is still there, we just overplotted points on top of it. Type "plt.clf()" to clear the figure, then try the same thing again: "plt.plot(humidity,temperature,'b.',markersize=12)". This should look much better.

Now, to add axis labels and a title, type the following:

plt.title('Fantastic Plot #1')
plt.xlabel('humidity (%)')
plt.ylabel('temperature (F)')

You can also change the axis ranges, like so;

plt.xlim(10,60)
plt.ylim(75,100)

Alternatively, these options can be set interactively from the plot window if you click on the check mark at the top. You can also click on the four-way arrow and drag your right mouse button inside the plot to resize the axes. For example, try using these plot window capabilities to zoom in on the humidity range from 10-40 and the temperature range from 80-100, thus excluding the two outlying data points in the plot. Of course, scientific integrity demands that you should never cut out a "bad" data point from a real data set without explaining why you're doing so, and having a very good reason!

Suppose you wanted to subselect certain data from your dataset for a legitimate reason, for example, let's say you just want to look at the temperature on days with humidity less than 20%. Rather than looking through the data, you can use the Numpy "where" function to select out those particular days. Type in "sel=np.where(humidity < 20)" and "print sel", so that you can see what sel is. What are the numbers in sel? Inspection in the Variable explorer shows that these numbers are the indices of the data points that meet our criteria (humidity is less than 20%). To check that sel does indeed find the data points where the humidity is less than 20%, type "print humidity[sel]". Now come up with a command to show the temperature values where the humidity level is < 20%. To check your answer, the temperature values should be: 89 and 93.

You can join multiple selection criteria together by using the "&" sign. Let's say rather than zooming in on your plot like we did earlier, you decide you just want to plot the data that meet certain criteria, i.e., temperature ranges from 80-100 and humidity from 10-40. To start this selection, write "sel2=np.where((temperature > 80) & (temperature < 100))". Go ahead and overplot this selection: "plot(humidity[sel2],temperature[sel2],'g*',markersize=15)". You should find that the overplotted symbols range from 80-100 in temperature. Finish the selection to restrict the humidity range from 10-40. Overplot using 'r+' (red plus signs). Put this final combined selection into your Editor file.

To finalize your plot so you can submit it with your program file, first retitle the plot with your name and the assignment, e.g., "Jane Doe Python Tutorial", then save it (the zoomed in version with the bottom right point cut out and red plus signs overplotted) to a file. If you save to pdf it should be easy to print. Print your program out from the Editor window as well (you can do this directly from Spyder) and hand it in together with your plot.