OverviewTeaching: 10 min
Exercises: 15 minQuestions
- Are there any other features besides code, text and output?
- Learn how to access help.
- Learn how to use magics and shell commands.
- Learn how to use widgets.
We can get help on an object using a question mark:
import numpy as np np.sum?
Or two question marks to also see the source code:
List all names in a module matching pattern:
np.cumsum np.einsum np.einsum_path np.nancumsum np.nansum np.sum
%quickref shows a quick reference card of features and shortcuts:
Use Git and the optional Unix tools from the Windows Command Prompt
We can also capture the output of a shell command:
notebooks = !ls *.ipynb
Magics are a simple command language which significantly extend the power of Jupyter.
There are two kinds of magics:
%lsmagic lists all available line and cell magics:
Question mark shows help:
Additional magics can also be installed or created.
Widgets add more interactivity to Notebooks, allowing one to visualize and control changes in data, parameters etc.
from ipywidgets import interact
interactas a function
def f(x, y, s): return (x, y, s) interact(f, x=True, y=1.0, s="Hello");
interactas a decorator
@interact(x=True, y=1.0, s="Hello") def g(x, y, s): return (x, y, s)
Does it not work? Extensions need to be installed.
The widgets interface have to be installed. JupyterLab is modular, and some parts need to be installed as an extension. In general, copy and paste the command into a shell (the JupyterLab shell works fine). See the installation instructions.
After installation, you need to reload the page to make it active (and if you installed it with pip or conda, restart the whole JupyterLab server)
A few useful magic commands
Using the computing-pi notebook, practice using a few magic commands. Remember that cell magics need to be on the first line of the cell.
- In the cell with the for-loop over
num_points(throwing darts), add the
%%timeitcell magic and run the cell.
- In the same cell, try instead the
%%pruncell profiling magic.
- Try introducing a bug in the code (e.g., use an incorrect variable name:
points.append((x, y2, True)))
- run the cell
- after the exception occurs, run the
%debugmagic in a new cell to enter an interactive debugger
hfor a help menu, and
help <keyword>for help on keyword
p xto print the value of
- exit the debugger by typing
- Have a look at the output of
%lsmagic, and use a question mark and double question mark to see help for a magic command that raises your interest.
Playing around with a widget
Widgets can be used to interactively explore or analyze data.
- We return to the pi approximation example and create a new cell where we reuse code that we have written earlier but this time we place the code into functions. This “hides” details and allows us to reuse the functions later or in other notebooks:
import random from ipywidgets import interact, widgets %matplotlib inline from matplotlib import pyplot def throw_darts(num_points): points =  hits = 0 for _ in range(num_points): x, y = random.random(), random.random() if x*x + y*y < 1.0: hits += 1 points.append((x, y, True)) else: points.append((x, y, False)) fraction = hits / num_points pi = 4 * fraction return pi, points def create_plot(points): x, y, colors = zip(*points) pyplot.scatter(x, y, c=colors) def experiment(num_points): pi, points = throw_darts(num_points) create_plot(points) print("approximation:", pi)
- Try to call the
experimentfunction with e.g.
num_pointsset to 2000.
- Add a cell where we will make it possible to vary the number of points interactively:
interact(experiment, num_points=widgets.IntSlider(min=100, max=10000, step=100, value=1000))
If you run into
Error displaying widget: model not found, you may need to refresh the page.
- Drag the slider back and forth and observe the results.
- Can you think of other interesting uses of widgets?
RShiny is a nice R alternative/solution à la ipywidgets
RShiny is a nice R alternative/solution a la ipywidgets which can be interesting for R developers.
See for instance their gallery of examples.
Jupyter notebooks have a number of extra features that can come in handy.