Getting Started with Jupyter Notebooks and Python

by Jeffrey Kantor (jeff at nd.edu). The latest version of this notebook is available at https://github.com/jckantor/CBE20255.

Summary

The purpose of this Jupyter Notebook is to get you started using Jupyter Notebooks and Python for routine chemical engineering calculations. This introduction assumes this is your first exposure to Python or Jupyter Notebook.

Step 0: Finding a Way to Run a Jupyter Notebook

Jupyter notebooks are documents that can be viewed and executed using any modern web browser. Since you're reading this, you already know how to view a Jupyter notebook. The next step is to learn how to execute the computations that may be embedded in a Jupyter notebook.

To execute code in a notebook you will need access to a computation. You can do this through an on-line cloud-based service or by installing a suitable computational environment on your laptop.

Using Jupyter/Python in the Cloud

The easiest approach is to sign up for a free account on a cloud-based service such as Wakari.io or SageMathCloud. You will need continuous internet connectivity to access your work, but the advantages are there is nothing to install, no software to maintain. All you need is a modern web browser on your laptop, Chromebook, tablet or other device.

There are also demonstration sites in the cloud, such as tmpnb.org. These will start up a interactive session where you can upload an existing notebook or create a new one from scratch. Though convenient, these sites are intended mainly for demonstration. There give you no way to retain your work between sessions, and not all functionality is available.

Installing Jupyter/Python on your Laptop

To gain off-line access you can install a Jupyter Notebook and Python development environment directly on your laptop. This will provide you with reliable off-line access to a computational environment. You can also additional libraries to add functionaility for your particular needs. This choice does requires an initial installation and routine updates.

There are several Jupyter/Python packages available. Among the best packages available for free download are:

There are differences between these packages, particularly in the methods used to download and maintain additional Python libraries. In both cases the process for downloading and installing the software are well documented and easy to follow. Allow about 10-30 minutes for the installation depending on your connection speed.

Skip Python 2.x, Install Python 3.x

The Python language has undergone revision since it was first releaed in 1991. In particular, Python 3 was released in 2008 and included some feature improvements that 'broke' older codes. It has taken much effort and time to update the extensive libraries required scientific and engineering use, so there has been a period of nearly a decade where Python versions 2.x and 3.x have been in common use.

Currently, the projected end-of-life for Python 2.7 (the latest release of Python 2) is 2020. Almost all major libraries are now Python 3 compatible. For those reasons, I strongly encourage you do download and install Python 3. All of the notebooks in this repository are written for Python 3.

Maintaining your Installation

After installing, be sure to check for updates before proceeding further. With the Anaconda package this is done by executing the following two commands in a terminal window:

> conda update conda
> conda update anaconda

Anaconda includes an 'Anaconda Navigator' application that simplify startup of the notebook environment and manage the update process.

In [1]:
from IPython.display import YouTubeVideo
YouTubeVideo("YJC6ldI3hWk",560,315,rel=0)
Out[1]:

Step 1: Start a Jupyter Notebook Session

If you are using a cloud-based service a Jupyter session will be started when you log on.

If you have installed a Jupyter/Python distribution on your laptop then you can open a Jupyter session in one of two different ways:

  • Use the Anaconda Navigator App, or
  • open a terminal window on your laptop, then execute the following statement at the command line:

      > jupyter notebook

Either way, once you have opened a session you should see a browser window like this:

Screen Shot Jupyter Session

The Jupyter browser displays a list of directories and files. You can navigate amoung the directories in the usual way by clicking on directory names or on the 'breadcrumbs' located just about the listing.

Jupyter notebooks are simply files in a directory with a .ipynb suffix. They can be stored in any directory including Dropbox or Google Drive. Upload and create new Jupyter notebooks in the displayed directory using the appropriate buttons. Use the checkboxes to select items for other actions, such as to duplicate, to rename, or to delete notebooks and directories.

An Jupyter notebook consists of cells that hold headings, text, or python code. The user interface is relatively self-explanatory. Take a few minutes now to open, rename, and save a new notebook.

Step 2: Experiment with Python

Python is an elegant and modern language for programming and problem solving that has found increasing use by engineers and scientists. In the next few cells we'll demonstrate some basic Python functionality.

Basic Arithmetic Operations

Basic arithmetic functions

In [2]:
a = 12
b = 2
print("a + b = ", a + b)
print("a**b = ", a**b)
print("a/b = ", a/b)
a + b =  14
a**b =  144
a/b =  6.0

Most math functions are in the numpy library. This next cell shows how to import numpy with the prefix np, then use it to call a common function

In [3]:
import numpy as np
np.sin(2*np.pi)
Out[3]:
-2.4492935982947064e-16

Working with Lists

Lists are a versatile way of organizing your data in Python. Here are some examples, more can be found on this Khan Academy video.

In [4]:
xList = [1, 2, 3, 4]
print(xList)
[1, 2, 3, 4]

Concatentation is the operation of joining one list to another.

In [5]:
# Concatenation
x = [1, 2, 3, 4];
y = [5, 6, 7, 8];

x + y
Out[5]:
[1, 2, 3, 4, 5, 6, 7, 8]

A common operation is to apply a binary operation to elements of a single list. For an example such as arithmetic addition, this can be done using the sum function from numpy.

In [6]:
# Two ways to sum a list of numbers
print(np.sum(x))
10

A for loop is a means for iterating over the elements of a list. The colon marks the start of code that will be executed for each element of a list. Indenting has meaning in Python. In this case, everything in the indented block will be executed on each iteration of the for loop.

In [7]:
for x in xList:
    print("x =", x, "    sin(x) = ", np.sin(x))
x = 1     sin(x) =  0.841470984808
x = 2     sin(x) =  0.909297426826
x = 3     sin(x) =  0.14112000806
x = 4     sin(x) =  -0.756802495308

Working with dictionaries

Dictionaries are useful for storing and retrieving data as key-value pairs. For example, here is a short dictionary of molar masses. The keys are molecular formulas, and the values are the corresponding molar masses.

In [8]:
mw = {'CH4': 16.04, 'H2O': 18.02, 'O2':32.00, 'CO2': 44.01}
print(mw)
{'CH4': 16.04, 'H2O': 18.02, 'O2': 32.0, 'CO2': 44.01}

We can a value to an existing dictionary.

In [9]:
mw['C8H18'] = 114.23
print(mw)
{'CH4': 16.04, 'H2O': 18.02, 'C8H18': 114.23, 'O2': 32.0, 'CO2': 44.01}

We can retrieve a value from a dictionary.

In [10]:
mw['CH4']
Out[10]:
16.04

A for loop is a useful means of interating over all key-value pairs of a dictionary.

In [11]:
for species in mw.keys():
    print("The molar mass of {:<s} is {:<7.2f}".format(species, mw[species]))
The molar mass of CH4 is 16.04  
The molar mass of H2O is 18.02  
The molar mass of C8H18 is 114.23 
The molar mass of O2 is 32.00  
The molar mass of CO2 is 44.01  

Dictionaries can be sorted by key or by value

In [12]:
for species in sorted(mw):
    print(" {:<8s}  {:>7.2f}".format(species, mw[species]))
 C8H18      114.23
 CH4         16.04
 CO2         44.01
 H2O         18.02
 O2          32.00
In [13]:
for species in sorted(mw, key = mw.get):
    print(" {:<8s}  {:>7.2f}".format(species, mw[species]))
 CH4         16.04
 H2O         18.02
 O2          32.00
 CO2         44.01
 C8H18      114.23

Plotting

Importing the matplotlib.pyplot library gives IPython notebooks plotting functionality very similar to Matlab's. Here are some examples using functions from the

In [14]:
import matplotlib.pyplot as plt
import numpy as np
%matplotlib inline

x = np.linspace(0,10)
y = np.sin(x)
z = np.cos(x)

plt.plot(x,y,'b',x,z,'r')
plt.xlabel('Radians');
plt.ylabel('Value');
plt.title('Plotting Demonstration')
plt.legend(['Sin','Cos'])
plt.grid()
In [15]:
plt.plot(y,z)
plt.axis('equal')
Out[15]:
(-1.09972447591003,
 1.0979832896606587,
 -1.0992804688576738,
 1.0999657366122702)
In [16]:
plt.subplot(2,1,1)
plt.plot(x,y)
plt.title('Sin(x)')

plt.subplot(2,1,2)
plt.plot(x,z)
plt.title('Cos(x)')
Out[16]:
<matplotlib.text.Text at 0x113048358>

Step 3: Solve Equations using Sympy

One of the best features of Python is the ability to extend it's functionality by importing special purpose libraries of functions. Here we demonstrate the use of a symbolic algebra package Sympy for routine problem solving.

In [17]:
import sympy as sym

sym.var('P V n R T');

# Gas constant
R = 8.314        # J/K/gmol
R = R * 1000     # J/K/kgmol

# Moles of air
mAir = 1         # kg
mwAir = 28.97    # kg/kg-mol
n = mAir/mwAir   # kg-mol

# Temperature
T = 298

# Equation
eqn = sym.Eq(P*V,n*R*T)

# Solve for P 
f = sym.solve(eqn,P)
print(f[0])

# Use the sympy plot function to plot
sym.plot(f[0],(V,1,10),xlabel='Volume m**3',ylabel='Pressure Pa')
85521.9882637211/V
Out[17]:
<sympy.plotting.plot.Plot at 0x11302c048>

Step 4: Learn More

Python offers a full range of programming language features, and there is a seemingly endless range of packages for scientific and engineering computations. Here are some suggestions on places you can go for more information on programming for engineering applications in Python.

Introduction to Python for Science

This excellent introduction to python is aimed at undergraduates in science with no programming experience. It is free and available at the following link.

Tutorial Introduction to Python for Science and Engineering.

The following text is licensed by the Hesburgh Library for use by Notre Dame students and faculty only. Please refer to the library's acceptable use policy. Others can find it at Springer or Amazon. Resources for this book are available on github.

pycse is a package of python functions, examples, and document prepared by John Kitchin at Carnegie Mellon University. It is a recommended for its coverage of topics relevant to chemical engineers, including a chapter on typical chemical engineering computations.

Interative learning and on-line tutorials

Official documentation, examples, and galleries.

In [ ]: