This document is a very brief introduction to using IPython in the Jupyter Notebook as a tool for solving numerical problems in Physical Science courses. It assumes very little knowledge of computer programming and focusses on how to use this tool to solve textbook problems.

Contents:

*Last modified November, 2018 by Archie Paulson (Madison College, WI)*

Python is a powerful, high-level programming language, used very widely in diverse settings. It is heavily used at Google and NASA (among many others), and is one of the most popular of all programming languages. With many powerful and efficient libraries written for numerical computation, Python has become quite popular in scientific computing. For example, numerical integration, linear algebra, Fourier tranforms and much more are efficiently performed with the NumPy libraries, while Pandas performs data manipulation and analysis, and matplotlib offers a 2D plotting library to produce publication-quality graphs.

IPython harnesses all this power in a convenient interactive terminal interface, and the Jupyter Notebook wraps it all in a "web-based application suitable for capturing the whole computation process: developing, documenting, and executing code, as well as communicating the results." The result is an environment resembling MATLAB or Mathematica. The project continues to improve under active development. All of its components are both free (as in freedom) and free (as in free beer).

Although Python is a powerful programming language, we introduce some of its basic features here by using the notebook as a calculator. To try it yourself, visit try.jupyter.org and choose "Python 3" from the "New" dropdown menu (see Get Started, below).

Type something to evaluate, and hit *shift-enter* to perform the computatation:

In [1]:

```
1+2+3
1 + 3 * 1000
```

Out[1]:

`Out`

line (unless you tell it to `print`

). Standard order of operations are obeyed. Any text after a '`#`

' is a comment that does not get executed.

In [3]:

```
print (1+2+3)
print (1 + 3 * 1000)
print (1.6e-19) # scientific notation using 'e'
print ("the answer is", 10**2) # this is how to raise to a power
9e9 * 1.6e-19 / 1e-3**2
```

Out[3]:

The last output can be re-used with the `_`

character.

In [4]:

```
_ *100
```

Out[4]:

We start to use the power of programming when we use variables to store values. This is easy to do:

In [4]:

```
G = 6.67e-11
m1, m2, r = 5.97e24, 1.0, 6.37e6
G*m1*m2/r**2
```

Out[4]:

In [5]:

```
m2 = 15.5
F = G*m1*m2/r**2
print ('force of gravity for a mass of',m2,'kg is', F, 'Newtons')
```

Notice how the Notebook shows the input text in colors (called syntax highlighting) to identify the different components of your commands.

"I could do all that on my calculator," you may say. But consider some of the advantages of using the Notebook:

**edit and refine with marginal extra effort**: Did you make a simple mistake on your calculator? Then re-enter the entire problem, hoping you get it right the next time. Or, quickly edit and re-run your entry in the Notebook. Easily double check your answer before you commit to it. This ability becomes invaluable in problems with several steps.**save and share your results**: Just save the notebook that holds your homework calculations (give it a name and control-S). Go back to it later without losing anything. If your peers need help you can show them your work and collaborate. If you get stuck and need help, show your instructor how you started the problem. Include your own text comments in the notebook to study or review later; remember why you did it that way. A future homework or project may have components similar to today's homework problems; you'll have a substantial head-start if you save your work now.**keep all significant figures**: A common error in problem-solving is to round results in the middle of a long calculation -- this can lead to "round-off error", giving a final answer outside of the acceptable error tolerance. Instead let the computer do it and maintain its extremely high precision.**let the computer do the drudgery**: That's what they are for. Spend your time and effort getting the concepts straight, not typing away at your calculator.**learn a powerful tool**: Getting the hang of a programming language now may pay off big in the future, when the problems become larger than a calculator can handle. Programming ability is a big plus on a resume.

The power of Python is really in the many libraries available to you. We will want the mathematical functionality of Numpy (numerical python) to do square roots and trig functions and to provide constants like $\pi$.

We must import the *numpy* libraries before we can use them. This can be done in more than one way; for our purposes the following is recommended:

In [5]:

```
from numpy import *
print ( pi, e, sqrt(2) )
print ( cos(pi), log(e), arccos(0.5)/pi )
```

Note the trig functions use radians, and logs are natural logs.

Vectors in this context are called arrays, and their components are indexed as 0,1,2.

In [6]:

```
a = array( (10., 55, 60) )
print('vector a is',a)
print('it has components',a[0],a[1],'and', a[2])
```

In [9]:

```
dtr = pi/180 # we will use this factor to convert degrees to radians
f1_magitude = 50. # Newtons
theta1 = 45*dtr # radians
f2_magitude = 25. # Newtons
theta2 = -30*dtr # radians
f1 = f1_magitude * array((cos(theta1),sin(theta1)))
f2 = f2_magitude * array((cos(theta2),sin(theta2)))
f1 + f2
```

Out[9]:

Note: to show an image like you see above you can write html code (as above). To show mathematical text like $\vec{F}$, write the LaTeX code for the mathematical objects between $ signs.

Let's find the magnitude and direction of this vector:

In [11]:

```
F = f1 + f2
F_mag = sqrt( F[0]**2 + F[1]**2 )
F_dir = arctan( F[1]/F[0] ) / dtr # convert radians to degrees
print ('magnitude is {:0.2f} N and direction is {:0.1f} degrees'.format(F_mag,F_dir))
```

Everything you really need to get started is illustrated above. You may want to start playing around to see it in action. Consider editting this notebook (available here) or starting a new one (see Get Started, below).

What follow are a few extras you might also want to consider.

If you are viewing this document as a notebook, you will have noticed different types of cells appear: code (where the Python instructions are run), and text with some simple formatting (like *this*). You can specify the type of cell you want with the Notebook dropdown menu near the top. Text cells are called "markdown" cells -- markdown refers to a simple way to put links and formatting into your text.

The menus in the Notebook allow you to split the cell you're working in, delete a cell, copy and paste cells, *et cetera*. When you start working on notebooks you'll probably want to know some of the keyboard shortcuts to do these things -- see the Help menu in the Jupyter notebook for a complete list of them.

If there are several steps you perfrom over and over, consider writing a function to do them. For example, a function to find the magnitude of a vector could be:

In [14]:

```
def magnitude(vec):
v2 = vec**2 # squares each component of array
mag2 = sum(v2) # adds up components of squared-array
mag = sqrt(mag2)
return mag
A = array((3,4,0))
B = array((cos(30*dtr),sin(30*dtr)))
print ('magnitude of A =', magnitude(A))
print ('magnitude of B =', magnitude(B))
```

`if`

" statements and more in the Python tutorial. You can eventually get sophisticated with the full object-oriented power of Python.

Plotting data is accomplished with matplotlib. It must first be activated and imported as follows:

In [11]:

```
%matplotlib inline
import matplotlib.pyplot as plt
```

*x* and *y* data to be graphed) to the `plot`

function. It is common here to use the `linspace`

function to make the *x*-values we want to see. `linspace`

requires an initial *x*, final *x*, and the number of *x* values to include. Here's an example showing two plots on a graph:

In [12]:

```
x = linspace(-3,3,1000) # defines the plot domain
y = e**(-x**2)
plt.plot(x,y)
plt.plot(x,sin(x))
```

Out[12]:

When you want to share a noteboook you have a few options. Before you do so make sure it's all working as you intended. you can double-check this as follows: restart the kernel (with the menu at the top of the Notebook) and `Run All`

from the `Cell`

menu. Scan the final document for any errors, and save it (control-S) if it looks good.

The simplest way to share the notebook is to send your colleague the `.ipynb`

file that you just saved. This method will only work if she can run the file with her own Notebook server, in which case she would drag the file onto her Notebook dashboard, then run and edit it.

An easy way to share the notebook (read-only) is to save the `.ipynb`

file on the web where it has a URL. Visit nbviewer.jupyter.org
and paste this URL into the box there. The nbviewer will render the `.ipynb`

file as a webpage which can then be shared broadly. The `nbviewer`

page has an icon at the top that will allow visitors to download the `.ipynb`

file if they like. For this method to work you need to have access to a webserver to host the `.ipynb`

file -- you might be interested in getting an account with a free web hosting service (I have used 000webhost for small projects).

Another option is to make an html file from the notebook. Then you can either send the html file to your audience or post it publically and direct them to its web address. You can obtain the html version in the File menu, choosing to "download as" html.

You can try working with notebooks in a temporary test space at try.jupyter.org. Find the "New" dropdown menu at the right and select "Python 3" for a blank notebook. Try to copy and paste some of the above cells as an example. Note that this site is best for just trying jupyter; all work is deleted after 10 minutes of inactivity.

To get your own Notebook running, you might follow the instructions on this how-to page.