The Jupyter notebook¶
IPython provides a kernel for Jupyter. Jupyter is the name for this notebook interface, and the document format.
Notebooks can contain Markdown like this cell here, as well as mathematics rendered with mathjax:
$$ \frac{1}{\Bigl(\sqrt{\phi \sqrt{5}}-\phi\Bigr) e^{\frac25 \pi}} = 1+\frac{e^{-2\pi}} {1+\frac{e^{-4\pi}} {1+\frac{e^{-6\pi}} {1+\frac{e^{-8\pi}} {1+\ldots} } } } $$!head -n 32 "Intro to IPython.ipynb"
nbviewer is a service that renders notebooks to HTML, for sharing and reading notebooks on the Internet.
This notebook on nbviewer.
You can also convert notebooks to HTML and other formats locally with jupyter nbconvert.
IPython: beyond plain Python¶
Follow along: https://github.com/minrk/inf3331-ipython
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:
Alt-Enterto force the creation of a new cell unconditionally (useful when inserting new content in the middle of an existing notebook).Control-Enterexecutes the cell and keeps the cursor in the same cell, useful for quick experimentation of snippets that you don't need to keep permanently.
print("Hi")
import time
for i in range(10):
print(i, end=' ')
time.sleep(1)
i
Getting help:
?
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.
import collections
collections.namedtuple?
collections.Counter??
c = collections.Counter('abcdeabcdabcaba')
c.most_common?
c.most_common(2)
with '*', you can do a wildcard search:
*int*?
import numpy as np
np.*array*?
An IPython quick reference card:
%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.
np.array2string
The interactive workflow: input, output, history¶
2+10
_+10
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):
10+20;
_
The output is stored in _N and Out[N] variables:
Out[21]
_15 == Out[15]
%history lets you view and search your history
%history -n 1-5
Exercise
Using this info, how could we write the last 10 lines of history to a file?
Accessing the underlying operating system¶
import os
print(os.getcwd())
!pwd
!ls -la
ls
files = !ls
print("My current directory's files:")
print(files)
for f in files:
print(f * 2)
!echo $files
!echo {files[0].upper()}
Note that all this is available even in multiline blocks:
import os
for i,f in enumerate(files):
if f.endswith('ipynb'):
!echo {"%02d" % i} - "{os.path.splitext(f)[0]}"
else:
print('--')
%history -t 22
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:
To provide an orthogonal namespace for controlling IPython itself and exposing other system-oriented functionality.
To expose a calling mode that requires minimal verbosity and typing while working interactively. Thus the inspiration taken from the classic Unix shell style for commands.
Line vs cell magics:
%timeit list(range(1000))
%%timeit
list(range(10))
list(range(100))
Line magics can be used even inside code blocks:
for i in range(1, 5):
size = i*100
print('size:', size, end=' ')
%timeit list(range(size))
%timeit time.sleep(0.1)
%timeit?
Magics can do anything they want with their input, so it doesn't have to be valid Python:
%%bash
echo "My shell is:" $SHELL
echo "My disk usage is:"
df -h
%%ruby
puts "hello"
Another interesting cell magic: create any file you want locally from the notebook:
%%writefile test.txt
This is a test file!
It can contain anything I want...
And more...
!cat test.txt
Let's see what other magics are currently defined in the system:
%lsmagic
import math
math.pi
%precision 2
math.pi
%precision?
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:
>>> # Fibonacci series:
... # the sum of two elements defines the next
... a, b = 0, 1
>>> while b < 10:
... print(b)
... a, b = b, a+b
import sys
for i in range(32):
print(i, end=' ')
time.sleep(0.1)
And when your code produces errors, you can control how they are displayed with the %xmode magic:
%%writefile mod.py
def f(x):
return 1.0/(x-1)
def g(y):
return f(y+1)
Now let's call the function g with an argument that would produce an error:
import mod
mod.g(0)
%xmode verbose
mod.g(0)
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:
%debug
Don't foget to exit your debugging session. Raw input can of course be use to ask for user input:
colour = input('What is your favourite colour? ')
print('colour is:', colour)
Running code in other languages with special %% magics¶
%%perl
@months = ("July", "August", "September");
print $months[0];
%%ruby
name = "world"
puts "Hello #{name.capitalize}!"
Plotting in the notebook¶
This magic configures matplotlib to render its figures inline:
%matplotlib inline
import numpy as np
import matplotlib.pyplot as plt
x = np.linspace(0, 2*np.pi, 300)
y = np.sin(x**2)
plt.plot(x, y)
plt.title("A little chirp")
fig = plt.gcf() # let's keep the figure object around for later...
Widgets¶
from ipywidgets import interact
@interact
def show_args(num=5, text='hello', check=True):
print(locals())
import sympy
from sympy import Symbol, Eq, factor
x = Symbol('x')
sympy.init_printing(use_latex='mathjax')
x
@interact(n=(1,21))
def factorit(n):
return Eq(x**n-1, factor(x**n-1))