Jupiter Notebook Tips & Tricks

Importing functions from another jupyter notebook

The nbimporter module helps us here:

pip install nbimporter

For example, with two notebooks in this directory structure:




class Configuration_nb():
    def __init__(self):
        print('hello from configuration notebook')


import nbimporter
from src import configuration_nb

new = configuration_nb.Configuration_nb()


Importing Jupyter notebook from ......\src\configuration_nb.ipynb
hello from configuration notebook

We can also import and use modules from python files.


class Configuration():
    def __init__(self):
        print('hello from configuration.py')


import nbimporter
from src import configuration

new = configuration.Configuration()


hello from configuration.py

ipynb import another ipynb file

%run MyOtherNotebook.ipynb

1. Executing Shell Commands

The notebook is the new shell

The shell is a way to interact textually with the computer. The most popularUnix shell is Bash(Bourne Again SHell ). Bash is the default shell on most modern implementations of Unix and in most packages that provide Unix-like tools for Windows.

Now, when we work with any Python interpreter, we need to regularly switch between the shell and the IDLE, in case we need to use the command line tools. However, the Jupyter Notebook gives us the ease to execute shell commands from within the notebook by placing an extra !before the commands. Any command that works at the command-line can be used in IPython by prefixing it with the ! character.

In [1]: !ls
example.jpeg list tmp
In [2]: !pwd
/home/Parul/Desktop/Hello World Folder'
In [3]: !echo "Hello World"
Hello World

We can even pass values to and from the shell as follows:

In [4]: files= !ls
In [5]: print(files)
['example.jpeg', 'list', 'tmp']
In [6]: directory = !pwd
In [7]: print(directory)
['/Users/Parul/Desktop/Hello World Folder']
In [8]: type(directory)

Notice, the data type of the returned results is not a list.

2. Jupyter Themes

Theme-ify your Jupyter Notebooks!

If you are a person who gets bored while staring at the white background of the Jupyter notebook, themes are just for you. The themes also enhance the presentation of the code. You can find more about Jupyter themes here. Let’s get to the working part.


pip install jupyterthemes

List of available themes

jt -l

Currently, the available themes are chesterish, grade3, gruvboxd, gruvboxl monokai, oceans16, onedork, solarizedd ,solarizedl.

# selecting a particular theme
jt -t <name of the theme>
# reverting to original Theme
jt -r
  • You will have to reload the jupyter notebook everytime you change the theme, to see the effect take place.

  • The same commands can also be run from within the Jupyter Notebook by placing ‘!’ before the command.

Left: original | Middle: Chesterish Theme | Right: solarizedl theme

3. Notebook Extensions

Extend the possibilities

Notebook extensions let you move beyond the general vanilla way of using the Jupyter Notebooks. Notebook extensions (or nbextensions) are JavaScript modules that you can load on most of the views in your Notebook’s frontend. These extensions modify the user experience and interface.


Installation with conda:

conda install -c conda-forge jupyter_nbextensions_configurator

Or with pip:

pip install jupyter_contrib_nbextensions && jupyter contrib nbextension install
#incase you get permission errors on MacOS,
pip install jupyter_contrib_nbextensions && jupyter contrib nbextension install --user

In case you couldn’t find the tab, a second small nbextension, can be located under the menuEdit.

Let us discuss some of the useful extensions.

1. Hinterland

2. Snippets

3. Split Cells Notebook

This extension splits the cells of the notebook and places then adjacent to each other.

4. Table of Contents

5. Collapsible Headings

6. Autopep8

Autopep8 helps to reformat/prettify the contents of code cells with just a click. If you are tired of hitting the spacebar again and again to format the code, autopep8 is your savior.

4. Jupyter Widgets

Make notebooks interactive

Widgets are eventful python objects that have a representation in the browser, often as a control like a slider, textbox, etc. Widgets can be used to build interactive GUIs for the notebooks.


# pip
pip install ipywidgets
jupyter nbextension enable --py widgetsnbextension
# Conda
conda install -c conda-forge ipywidgets
#Installing ipywidgets with conda automatically enables the extension

Let us have a look at some of the widgets. For complete details, you can visit their Github repository.


The interact function (ipywidgets.interact) automatically creates a user interface (UI) controls for exploring code and data interactively. It is the easiest way to get started using IPython's widgets.

# Start with some imports!
from ipywidgets import interact
import ipywidgets as widgets

1. Basic Widgets

def f(x):
    return x
# Generate a slider 
interact(f, x=10,);
# Booleans generate check-boxes
interact(f, x=True);
# Strings generate text areas
interact(f, x='Hi there!');

2. Advanced Widgets

Here is a list of some of the useful advanced widgets.

Play Widget

The Play widget is useful to perform animations by iterating on a sequence of integers at a certain speed. The value of the slider below is linked to the player.

play = widgets.Play(
    # interval=10,
    description="Press play",
slider = widgets.IntSlider()
widgets.jslink((play, 'value'), (slider, 'value'))
widgets.HBox([play, slider])

Date picker

The date picker widget works in Chrome and IE Edge but does not currently work in Firefox or Safari because they do not support the HTML date input field.

    description='Pick a Date',

Color picker

    description='Pick a color',


tab_contents = ['P0', 'P1', 'P2', 'P3', 'P4']
children = [widgets.Text(description=name) for name in tab_contents]
tab = widgets.Tab()
tab.children = children
for i in range(len(children)):
    tab.set_title(i, str(i))

5. Qgrid

Make Data frames intuitive

Qgrid is also a Jupyter notebook widget but mainly focussed at dataframes. It uses SlickGrid to render pandas DataFrames within a Jupyter notebook. This allows you to explore your DataFrames with intuitive scrolling, sorting and filtering controls, as well as edit your DataFrames by double-clicking cells. The Github Repository contains more details and examples.


Installing with pip:

pip install qgrid
jupyter nbextension enable --py --sys-prefix qgrid
# only required if you have not enabled the ipywidgets nbextension yet
jupyter nbextension enable --py --sys-prefix widgetsnbextension

Installing with conda:

# only required if you have not added conda-forge to your channels yet
conda config --add channels conda-forge
conda install qgrid

6. Slideshow

Code is great when communicated.

Notebooks are an effective tool for teaching and writing explainable codes. However, when we want to present our work either we display our entire notebook(with all the codes) or we take the help of powerpoint. Not any more. Jupyter Notebooks can be easily converted to slides and we can easily choose what to show and what to hide from the notebooks.

There are two ways to convert the notebooks into slides:

1. Jupyter Notebook’s built-in Slide option

Now go to the directory where the notebook is present and enter the following code:

jupyter nbconvert *.ipynb --to slides --post serve
# insert your notebook name instead of *.ipynb

These slides have a drawback i.e. you can see the code but cannot edit it. RISE plugin offers a solution.

2. Using the RISE plugin

RISE is an acronym for Reveal.js — Jupyter/IPython Slideshow Extension. It utilized the reveal.js to run the slideshow. This is super useful since it also gives the ability to run the code without having to exit the slideshow.


1 — Using conda (recommended):

conda install -c damianavila82 rise

2 — Using pip (less recommended):

pip install RISE

and then two more steps to install the JS and CSS in the proper places:

jupyter-nbextension install rise --py --sys-prefix
#enable the nbextension:
jupyter-nbextension enable rise --py --sys-prefix

Refer to the documentation for more information.

6. Embedding URLs, PDFs, and Youtube Videos

Display it right there!

Why go with mere links when you can easily embed an URL, pdf, and videos into your Jupyter Notebooks using IPython’s display module.


#Note that http urls will not be displayed. Only https are allowed inside the Iframe
from IPython.display import IFrame
IFrame('https://en.wikipedia.org/wiki/HTTPS', width=800, height=450)


from IPython.display import IFrame
IFrame('https://arxiv.org/pdf/1406.2661.pdf', width=800, height=450)

Youtube Videos

from IPython.display import YouTubeVideo
YouTubeVideo('mJeNghZXtMo', width=800, height=300)

Drag'n'Drop Pivot Tables and Charts

To use PivotTable.js from Jupyter, first install it with pip install pivottablejs.

Then, if you have a Pandas DataFrame (from Pandas v0.14+, or any other object with a to_csv method which returns a string) called df just execute

from pivottablejs import pivot_ui

and you will get an interactive UI in your notebook.

What happens behind the scenes is that a local file called pivottablejs.html is written (overrideable behaviour with the outfile_path keyword arg), which contains your data in CSV form and some HTML/Javascript to load up the UI, which Jupyter then loads up in an iframe. You can also “pop out” of that frame into a full page, which is then saveable for later.

The pivottablejs Python module is available from PyPi under the same free MIT license as PivotTable.js. The source is up on Github and I’d love feedback, pull requests etc.

Last updated