This notebook was put together by Jake Vanderplas for UW's Astro 599 course. Source and license info is on GitHub.

IPython: an enviromnent for interactive computing

What is IPython?

IPython at the terminal

The basic IPython client: at the terminal, simply type ipython:

$ ipython
Python 2.7.4 (default, Apr 19 2013, 18:28:01) 
Type "copyright", "credits" or "license" for more information.

IPython 1.0.0 -- An enhanced Interactive Python.
?         -> Introduction and overview of IPython's features.
%quickref -> Quick reference.
help      -> Python's own help system.
object?   -> Details about 'object', use 'object??' for extra details.

In [1]: print "hello world"
hello world

The IPython book

Also introduces Numpy, Pandas and Matplotlib

Some other tutorial help/resources :

IPython: beyond plain Python

When executing code in IPython, all valid Python syntax works as-is, but IPython provides a number of features designed to make the interactive experience more fluid and efficient.

First things first: running code, getting help

In the notebook, to run a cell of code, hit Shift-Enter. This executes the cell and puts the cursor in the next cell below, or makes a new one if you are at the end. Alternately, you can use:

In [1]: 
print "Hello"

Hello

Getting help

In [2]: 
?

Help with ? and ??

Typing object_name? will print all sorts of details about any object, including docstrings, function definition lines (for call arguments) and constructor details for classes.

In [3]: 
import collections
collections.namedtuple?
In [4]: 
collections.Counter??
In [5]: 
*int*?

An IPython quick reference card:

In [6]: 
%quickref

Tab completion

Tab completion, especially for attributes, is a convenient way to explore the structure of any object you’re dealing with. Simply type object_name.<TAB> to view the object’s attributes. Besides Python objects and keywords, tab completion also works on file and directory names.

In [7]: 
collections.

  File "<ipython-input-7-7ca0d153ae00>", line 1
    collections.
                ^
SyntaxError: invalid syntax

The interactive workflow: input, output, history

In [8]: 
2+10
Out[8]:
12
In [9]: 
_+10
Out[9]:
22

Output control

You can suppress the storage and rendering of output if you append ; to the last cell (this comes in handy when plotting with matplotlib, for example):

In [10]: 
10+20;
In [11]: 
_
Out[11]:
22

Output history

The output is stored in _N and Out[N] variables:

In [12]: 
_10 == Out[10]

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
<ipython-input-12-af210d401e68> in <module>()
----> 1 _10 == Out[10]

NameError: name '_10' is not defined
In [13]: 
Out
Out[13]:
{8: 12, 9: 22, 11: 22}

And the last three have shorthands for convenience:

In [14]: 
print 'last output:', _
print 'next one   :', __
print 'and next   :', ___

last output: 22
next one   : 22
and next   : 12

The input history is also available

In [15]: 
In[11]
Out[15]:
u'_'
In [16]: 
_i
Out[16]:
u'In[11]'
In [17]: 
_ii
Out[17]:
u'In[11]'
In [18]: 
print 'last input:', _i
print 'next one  :', _ii
print 'and next  :', _iii

last input: _ii
next one  : _i
and next  : In[11]
In [19]: 
%history

print "Hello"
?
import collections
collections.namedtuple?
collections.Counter??
*int*?
%quickref
collections.
2+10
_+10
10+20;
_
_10 == Out[10]
Out
print 'last output:', _
print 'next one   :', __
print 'and next   :', ___
In[11]
_i
_ii
print 'last input:', _i
print 'next one  :', _ii
print 'and next  :', _iii
%history

Accessing the underlying operating system

Note: the commands below work on Linux or Macs, but may behave differently on Windows, as the underlying OS is different. IPython's ability to access the OS is still the same, it's just the syntax that varies per OS.

In [20]: 
!pwd

/Users/jakevdp/Opensource/2013_fall_ASTR599/notebooks
In [21]: 
files = !ls
print "My current directory's files:"
print files

My current directory's files:
['00_intro.ipynb', '01_basic_training.ipynb', '02_advanced_data_structures.ipynb', '03_IPython_intro.ipynb', '04_Functions_and_modules.ipynb', '05_NumpyIntro.ipynb', '05_Trapezoid_Solution.ipynb', '06_Denoise_Solution.ipynb', '06_MatplotlibIntro.ipynb', '07_GitIntro.ipynb', '08_ScipyIntro.ipynb', '09_AdvancedStrings.ipynb', '10_AdvancedPython2.ipynb', '11_EfficientNumpy.ipynb', '12_AdvancedMatplotlib.ipynb', 'README.txt', 'clean_data.dat', 'data', 'func_fortran.f', 'func_fortran.so', 'ggplot.rc', 'images', 'inout.dat', 'messy_data.dat', 'modfun.py', 'my_output.dat', 'myfile.html', 'myfile.py', 'myfile.pyc', 'mymodule.py', 'mymodule.pyc', 'mymodule2.py', 'mymodule2.pyc', 'number_game.py', 'test.npy', 'test.npz', 'test.out', 'tmp.py~']
In [22]: 
!echo $files

[00_intro.ipynb, 01_basic_training.ipynb, 02_advanced_data_structures.ipynb, 03_IPython_intro.ipynb, 04_Functions_and_modules.ipynb, 05_NumpyIntro.ipynb, 05_Trapezoid_Solution.ipynb, 06_Denoise_Solution.ipynb, 06_MatplotlibIntro.ipynb, 07_GitIntro.ipynb, 08_ScipyIntro.ipynb, 09_AdvancedStrings.ipynb, 10_AdvancedPython2.ipynb, 11_EfficientNumpy.ipynb, 12_AdvancedMatplotlib.ipynb, README.txt, clean_data.dat, data, func_fortran.f, func_fortran.so, ggplot.rc, images, inout.dat, messy_data.dat, modfun.py, my_output.dat, myfile.html, myfile.py, myfile.pyc, mymodule.py, mymodule.pyc, mymodule2.py, mymodule2.pyc, number_game.py, test.npy, test.npz, test.out, tmp.py~]
In [23]: 
!echo {files[0].upper()}

00_INTRO.IPYNB

Beyond Python: magic functions

The IPyhton 'magic' functions are a set of commands, invoked by prepending one or two % signs to their name, that live in a namespace separate from your normal Python variables and provide a more command-like interface. They take flags with -- and arguments without quotes, parentheses or commas. The motivation behind this system is two-fold:

In [24]: 
%magic

Line vs cell magics:

In [25]: 
%timeit range(10)

1000000 loops, best of 3: 375 ns per loop
In [26]: 
%%timeit
range(10)
range(100)

1000000 loops, best of 3: 1.06 µs per loop

Line magics can be used even inside code blocks:

In [27]: 
for i in range(5):
    size = i*100
    print 'size:',size, 
    %timeit range(size)

size: 0 10000000 loops, best of 3: 157 ns per loop
size: 100 1000000 loops, best of 3: 822 ns per loop
size: 200 1000000 loops, best of 3: 1.14 µs per loop
size: 300 100000 loops, best of 3: 1.83 µs per loop
size: 400 100000 loops, best of 3: 2.55 µs per loop

Magics can do anything they want with their input, so it doesn't have to be valid Python:

In [28]: 
%%bash
echo "My shell is:" $SHELL
echo "My memory status is:"
free

My shell is: /bin/bash
My memory status is:


bash: line 3: free: command not found

Another interesting cell magic: create any file you want locally from the notebook:

In [29]: 
%%file test.txt
This is a test file!
It can contain anything I want...

more...

Writing test.txt
In [30]: 
!cat test.txt

This is a test file!
It can contain anything I want...

more...

Let's see what other magics are currently defined in the system:

In [31]: 
%lsmagic
Out[31]:
Available line magics:
%alias  %alias_magic  %autocall  %automagic  %autosave  %bookmark  %cd  %clear  %colors  %config  %connect_info  %debug  %dhist  %dirs  %doctest_mode  %ed  %edit  %env  %gui  %hist  %history  %install_default_config  %install_ext  %install_profiles  %killbgscripts  %less  %load  %load_ext  %loadpy  %logoff  %logon  %logstart  %logstate  %logstop  %lsmagic  %macro  %magic  %man  %matplotlib  %more  %notebook  %page  %pastebin  %pdb  %pdef  %pdoc  %pfile  %pinfo  %pinfo2  %popd  %pprint  %precision  %profile  %prun  %psearch  %psource  %pushd  %pwd  %pycat  %pylab  %qtconsole  %quickref  %recall  %rehashx  %reload_ext  %rep  %rerun  %reset  %reset_selective  %run  %save  %sc  %store  %sx  %system  %tb  %time  %timeit  %unalias  %unload_ext  %who  %who_ls  %whos  %xdel  %xmode

Available cell magics:
%%!  %%HTML  %%SVG  %%bash  %%capture  %%debug  %%file  %%html  %%javascript  %%latex  %%perl  %%prun  %%pypy  %%python  %%python3  %%ruby  %%script  %%sh  %%svg  %%sx  %%system  %%time  %%timeit  %%writefile

Automagic is ON, % prefix IS NOT needed for line magics.

Running normal Python code: execution and errors

Not only can you input normal Python code, you can even paste straight from a Python or IPython shell session:

In [32]: 
>>> # Fibonacci series:
... # the sum of two elements defines the next
... a, b = 0, 1
>>> while b < 10:
...     print b
...     a, b = b, a+b

1
1
2
3
5
8
In [33]: 
In [1]: for i in range(10):
   ...:     print i,
   ...:     

0 1 2 3 4 5 6 7 8 9

Error display

And when your code produces errors, you can control how they are displayed with the %xmode magic:

In [34]: 
%%file mod.py

def f(x):
    return 1.0/(x-1)

def g(y):
    return f(y+1)

Writing mod.py

Now let's call the function g with an argument that would produce an error:

In [35]: 
import mod
mod.g(0)

---------------------------------------------------------------------------
ZeroDivisionError                         Traceback (most recent call last)
<ipython-input-35-a54c5799f57e> in <module>()
      1 import mod
----> 2 mod.g(0)

/Users/jakevdp/Opensource/2013_fall_ASTR599/notebooks/mod.py in g(y)
      4 
      5 def g(y):
----> 6     return f(y+1)

/Users/jakevdp/Opensource/2013_fall_ASTR599/notebooks/mod.py in f(x)
      1 
      2 def f(x):
----> 3     return 1.0/(x-1)
      4 
      5 def g(y):

ZeroDivisionError: float division by zero

Plain exceptions

In []: 
%xmode plain
mod.g(0)
In []: 












Verbose exceptions









In []:





%xmode verbose
mod.g(0)













The default %xmode is "context", which shows additional context but not all local variables. Let's restore that one for the rest of our session.









In []:





%xmode context



















Raw Input in the notebook







Since 1.0 the IPython notebook web application support raw_input which for example allow us to invoke the %debug magic in the notebook:















In []:





mod.g(0)
















In []:





%debug













Don't foget to exit your debugging session. Raw input can of course be use to ask for user input:









In []:





enjoy = raw_input('Are you enjoying this tutorial ?')
print 'enjoy is :', enjoy



















Plotting in the notebook







This imports numpy as np and matplotlib's plotting routines as plt, plus setting lots of other stuff for you to work interactivel very easily:









In []:





%pylab inline
















In []:





import numpy as np
import matplotlib.pyplot as plt
from matplotlib.pyplot import gcf
















In []:





x = np.linspace(0, 2*np.pi, 300)
y = np.sin(x**2)
plt.plot(x, y)
plt.title("A little chirp")
f = gcf()  # let's keep the figure object around for later...



















Working with Notebooks


Directory Layout







you will see the Notebooks in that directory in the dashboard






Notebook Files










In []:





from IPython.nbformat import current
with open('03_IPython_intro.ipynb') as f:
    nb = current.read(f, 'json')
















In []:





nb.worksheets[0].cells[0:5]


















Saving and Exporting


IPython Notebooks can also be exported to .py files (see "File:Download As" menu item). You can tell the Notebook server to always save these .py files alongside the .ipynb files by starting the Notebook as:


ipython notebook --script


You can import Notebooks from the main Dashboard or simply by copying a Notebook into the Notebook directory.






Overview of the UI







Cell types







Keyboard Shortcuts







Breakout #3: Notebook Practice






1. Using notebooks made available by others on the Internet


Find a Notebook shared from the IPython Notebook Gallery and Download it via http://nbviewer.ipython.org. Then import it into your running Notebook server using the Dashboard.






2. Basic cell operations


Recall, the Notebook can contain cells of the following types:



Create a new Notebook that has at least one of each cell type. Practice the following cell operations:







3. Keyboard shortcuts


Go back to that last Notebook and repeat some of those cell operations using keyboard shortcuts:







4. Markdown Cells


If you have time, download and explore this notebook, which will introduce you to the use of markdown cells in the notebook.