Notebook & Interactive Development Tools (Jupyter)

Introduction

Every library covered so far in this course is typically written and tested inside one particular tool before it ever reaches a production script: the Jupyter notebook. Instead of running an entire Python file top to bottom, a notebook lets you execute small, independent cells of code one at a time, seeing results, tables, and charts appear immediately below each cell.

This lesson covers Jupyter itself, then ipywidgets, a companion library for adding interactive controls like sliders and dropdowns directly inside a notebook.

What is Jupyter?

Jupyter is a project providing an interactive, cell-based computing environment for Python (and other languages). Its name comes from Julia, Python, and R — the three languages it originally targeted. Code is written and run in a .ipynb notebook file made up of individual cells, which can be executed independently and in any order, with output (text, tables, plots, or images) displayed directly beneath each cell.

There are two common ways to run notebooks: the classic notebook package, and JupyterLab, a more modern interface that adds a file browser, multiple tabs, and a more IDE-like layout around the same notebook file format.

Installing and Launching Jupyter

The jupyterlab package installs the modern interface (recommended for most new work), while notebook installs the classic, simpler interface. Both can open and run the same .ipynb files.

pip install jupyterlab
jupyter lab

Running jupyter lab starts a local web server and opens JupyterLab in your browser, where you can create new notebooks or open existing ones.

Example: Cell-Based Execution

Inside a notebook, each cell is run independently with Shift+Enter, and variables defined in one cell remain available to every cell that runs after it. This is what makes notebooks so well suited to data exploration — you can load a dataset once in an early cell, then experiment with dozens of different plots, filters, and models in later cells without reloading it each time.

# Cell 1
import pandas as pd
df = pd.DataFrame({
    "name": ["Alex", "Sam", "Riley"],
    "score": [88, 92, 79],
})
df

# Cell 2 — reuses the df defined in Cell 1
df["passed"] = df["score"] >= 80
df

Notice that Cell 2 uses the df variable created in Cell 1, and the notebook automatically renders the DataFrame as a formatted table rather than requiring a print() call — this rich, automatic display of the last expression in a cell is one of Jupyter's most useful features for data exploration.

Adding Interactivity with ipywidgets

ipywidgets adds interactive HTML controls, like sliders, dropdowns, and text boxes, directly inside a notebook cell, letting you explore how changing a parameter affects a result without rewriting and re-running code.

pip install ipywidgets

import ipywidgets as widgets
from IPython.display import display

def show_multiple(n):
    print(f"5 x {n} = {5 * n}")

slider = widgets.IntSlider(value=1, min=1, max=10, description="n:")
widgets.interact(show_multiple, n=slider)

Notebooks for Exploration, Not Production

Notebooks are the default environment for data science work because they match how exploratory analysis actually happens: load some data, look at it, try something, adjust, try again. Being able to re-run just one cell instead of an entire script makes that loop dramatically faster.

That same flexibility becomes a liability in production. Cells can be run out of order, leaving hidden state that does not match what the file would produce top-to-bottom; notebooks are harder to unit test, version-control cleanly, and review in a pull request compared to plain .py files. For this reason, code that starts life in a notebook is typically refactored into ordinary Python modules and scripts before it goes into a production pipeline.

Common Mistakes

Best Practices

Frequently Asked Questions

Key Takeaways

Summary

Jupyter is the interactive workbench where nearly all of the libraries in this course get explored, tested, and combined before any of that logic becomes a production script. Understanding its cell-based model, and knowing where its convenience ends and production discipline should begin, is a core data science skill in its own right.