Interactive Python in the Jupyter Notebook¶
Nathan Lloyd
To be covered:¶
- How to use Jupyter Notebook
- Some really basic python programming
- Some basic data analysis and plotting with pandas and matplotlib
Not covered:¶
- Installing python/anaconda/etc. (we can help you offline)
- Serious python programming (functions, classes, lambda functions, list comprehensions)
- How to write, manage, deploy software (e.g. git)
- More advanced math and science applications
- But here are some links for further learning:
- Google's python class: https://developers.google.com/edu/python/
- Harvey Mudd's free, online, at-your-own-pace course: https://www.edx.org/course/cs-all-introduction-computer-science-harveymuddx-cs005x-0#!
- Data science: http://dataschool.io/
- Software carpentry (kind of the next step after you just learned to write some scripts/programs): https://software-carpentry.org/
- Python treasure hunt: www.pythonchallenge.com
What is Jupyter?¶
- Jupyter is a notebook environment with a browser interface that can be used for interactive computing in Python and other languages (I haven't tried other languages).
- From when you open (or restart) a Jupyter notebook, variable assignments, function declarations, etc are stored and updated as you go.
- Basic usage:
- Type some code in a cell
- Hit
<shift><enter>to execute the cell - The return value or the string representation of the last line of the cell will be output below the code.
Saving¶
- The notebook periodically gets saved automatically, but you can also do File -> Save and Checkpoint
- You can change the name by clicking on the name (I like to do "Make a copy" periodically to explicitly save older versions)
In [1]:
my_name = 'ari'
In [2]:
my_name
Out[2]:
In [3]:
2 + 2
Out[3]:
In [4]:
example_variable = 2 + 2
In [5]:
example_variable
Out[5]:
In [6]:
example_variable = example_variable + 5
example_variable
Out[6]:
- Other key Jupyter features:
- tab completion (right now, if you type "exam" and hit
<tab>, it will complete with "example_variable") - easy access to function documentation
- syntax highlighting
%%timeat the beginning of a cell will print out how long it took to run the code
- tab completion (right now, if you type "exam" and hit
Jupyter editing¶
- Jupyter interactive editing is somewhat patterned after the unix editor vi (if you're a nerd and you happen to know what that is).
- You're either in edit mode or command mode. You can tell you're in edit mode if there is a blinking cursor in the highlighted cell.
- In edit mode, obviously, you edit the code.
- In command mode, there are a bunch of shortcut keys. For example, hitting 'm' changes cell type to "Markdown". Hitting 'l' adds line numbers. 'x' cuts (deletes) the cell. 'z' undoes the last cell deletion, but currently it only remembers one deletion back.
- Common mistake: starting to type while in command mode.
- More shortcut keys in command mode:
<shift><enter>to run the code in the cell- 'a' and 'b' create a new cell above or below the current cell
- 'c', 'x', 'v': copy, cut, paste.
- 'M' merges the current cell with the one below it.
- 'r' changes cell type to "Raw", which is useful as a quick way to clear lengthy output: hit 'r' then 'y' to change it back to type "Code"
- Shortcut keys in command mode:
<shift><enter>to run the code in the cell<command>zto undo edits- You can highlight a bunch of code and hit
<tab>to indent it - To split cells, click inside the cell where you want the split and hit
<ctrl><shift>- - Hit
<escape>while in edit mode to switch to command mode.
You can also change cell type using the "Cell" pull-down menu.
By the way, "Markdown" is what I'm using to make these nice text cells (you can even have tables!) - see Markdown Cheatsheet.
"Raw" is a good way to comment out a cell so it won't run.
Coding examples¶
In [7]:
# Execute me by hitting <shift><enter>
for i in range(7):
print(i)
A couple of really important points:¶
- Click inside the parentheses of the range function and hit
<shift><tab>to see documentation. range(7)spits out 0 to 6 because python indexing is 0-based. More on that later.- Stuff inside the for loop must be indented 4 spaces. Python is very much a stickler on this!
- (Explanation: the python interpreter considers the code inside the loop to begin after the ":" and end when you stop indenting 4 spaces)
Exercise: Predict in your head what the following code will print out, then try executing it.¶
In [8]:
for i in range(2):
print(i)
print("yo")
print("dude")
Exercise: below, add an argument to the print function to make it print out "0123456" without the newlines.¶
Hint: use <shift><tab> trick to see documentation for print function
In [12]:
for i in range(7):
print(i)
In [17]:
s = ""
for i in range(7):
s=s+str(i)
print(s)
In [20]:
for i in range(7):
print(i,end='')
In [ ]:
Execute cell below to get solution
In [ ]:
%load exercise_print_without_newline.py
Lists, tuples, dictionaries: containers of arbitrary things¶
- These are the most important data storage constructs in basic python
List¶
In [22]:
example_list = ['alpha', 'bravo', 2, print]
In [23]:
type(example_list)
Out[23]:
In [24]:
# Print each item in the list
for item in example_list:
print(item,end="")
In [25]:
# Access the second item in the list (0-based indexing!)
example_list[1]
Out[25]:
Tuple¶
In [26]:
example_tuple = ('alpha', 'bravo', 2, print)
In [27]:
type(example_tuple)
Out[27]:
In [28]:
for item in example_tuple:
print(item)
In [29]:
example_tuple[0]
Out[29]:
Tuple is just like list except it's static.
Use lists unless you know you need a tuple.
Dict¶
In [30]:
example_dict = {'a':63, 7:'a', 'g':print} # {key:value, key:value, key:value}
In [31]:
type(example_dict)
Out[31]:
In [32]:
example_dict
Out[32]:
In [33]:
example_dict['a']
Out[33]:
In [34]:
example_dict[7]
Out[34]:
In [35]:
# Raises Exception KeyError if you query a key that is not in the dict
# You can do example_dict.get(key, default_value) to gracefully return, e.g. 0 when the key is missing.
example_dict[15]
In [36]:
example_dict['g']
Out[36]:
Common mistake: example_dict[g] would throw an exception. You need those quotes.
In [37]:
# example_dict['g'] is a function, so we can use it like a function
example_dict['g']("you coding, bro?")
Strings¶
In [ ]:
' A String '
In [ ]:
type(' A String ')
In [42]:
# The str type has lots of useful functions
' A String '.strip().lower()
Out[42]:
Exercise¶
See what each of those functions, .strip() and .lower() do separately.
In [44]:
' A String k '.strip()
Out[44]:
In [41]:
'A String'.lower()
Out[41]:
In [48]:
dict
dictionary = {'g':print}
k = str(dictionary['g']('whAt up'))
print(k.lower())
#¶
In [ ]:
'Jack' == 'jack' # comparison of strings
In [ ]:
'Jack'.lower() == 'jack'.lower() # comparison of strings
In [ ]:
'time' + 'honey' # can "add" strings.
Exceptions¶
In [49]:
a = 'FANTASTIC!'
a.lower()
Out[49]:
In [50]:
a = 3
a.lower() # throws Exception
AttributeError is an exception that python throws when it gets this bad input.
Earlier we saw a dict throw the exception KeyError when I queried a key that wasn't present.
Often times an exception get thrown, like, 4 layers deep in function calls, e.g. e(f(g(h(whathaveyou))) and the function h has a problem operating on whathaveyou. In that case you get a traceback that shows the layers, which is long, but you get used to it.
Often the error message is not helpful. Keep calm and google it.
In [51]:
# Remember that crazy list of mixed types from earlier?
example_list = ['alpha', 'bravo', 2, print]
In [52]:
for item in example_list:
item('works!')
Here, TypeError is thrown on the first iteration of the for loop because the first item, 'alpha', is not a function, and you can only do something(input) if something is a function (well, there's other things it could be, e.g. a class, but you get the point).
In [ ]:
# try: except: clause to handle exceptions
for item in example_list:
try:
item('carl is my therapist')
except:
print("Error: {} doesn't work".format(item))
In [ ]:
# Can also get more information on what's causing the exception
for item in example_list:
try:
item('carl is my therapist')
except:
print("Error: {} doesn't work".format(item))
print(type(item))
Exercise:¶
- Store a string in a variable, example:
color = 'blue' - Make a list containing the functions
type,len, andstr.upper - Use a for loop to iterate over that list like so:
for func in your_list: - In the for loop, execute the current function with the variable you created as input, and print its output:
print(func(color))
In [53]:
color = 'blue'
In [54]:
listed = [type, len, str.upper]
In [57]:
for items in listed:
print(items(color))
Execute cell below to get solution
In [ ]:
%load exercise_list_functions.py
Followup exercise:¶
- Add the string
'nothing'to the list, so that we get an exception thrown when python tries to execute it. - Now put function call inside a
try: except:clause to gracefully handle the exception.
In [61]:
listed.append('nothing')
print(listed)
In [73]:
for func in listed:
try:
print(func(color))
except:
print('oh shit'.upper(),sep='',end='.')
In [ ]:
Execute cell below to get solution
In [ ]:
%load exercise_list_functions_try_except.py
Working with data¶
Example dataset: housing values for in Boston:
http://archive.ics.uci.edu/ml/datasets/Housing
In [74]:
import pandas as pd
import matplotlib.pyplot as plt
plt.style.use('ggplot')
%matplotlib inline
In [75]:
df = pd.read_csv('housing.txt', sep='\t')
In [76]:
df
Out[76]:
In [77]:
fig, ax = plt.subplots(1, 1)
ax.scatter(x=df['crime'], y=df['median_value'])
ax.set_xlabel('crime per capita')
ax.set_ylabel('median value / $1000');
In [78]:
fig, ax = plt.subplots(1, 1)
ax.scatter(x=df['nox'], y=df['median_value'])
ax.set_xlabel('Nitric oxides concentration (parts per 10M)')
ax.set_ylabel('median value / $1000')
Out[78]:
In [79]:
import numpy as np
In [80]:
fig, ax = plt.subplots(1, 1)
ax.scatter(x=df['nox'], y=df['median_value'], s=3*df['rooms']**2, c=np.sqrt(df['crime']), alpha=0.25, cmap='viridis')
ax.set_xlabel('Nitric oxides concentration (parts per 10M)')
ax.set_ylabel('median value / $1000')
Out[80]:
In [ ]:
df['median_value'].hist()