Set Up Jupyter Notebook

You've spent weeks wrestling with raw CSV files, repl.it sessions, or scripts that spew output into the void — and every analysis feels like a one-way trip. When someone asks, "How did you get that number?" you can't retrace your steps. The pain is real: disconnected code, lost context, and results that can't be reproduced. This lesson shows you how to set up Jupyter Notebook for analysis — the tool that turns your data work into a living, shareable story where every cell is a checkpoint and every chart has a trail.

The problem this lesson solves

Data analysis in plain Python scripts has a hidden tax: you write code, run it, get a result, then tweak a parameter and run again — but the intermediate outputs vanish. You're left with a pile of .py files and a foggy memory of what worked. Worse, when you want to explore data interactively — slice a DataFrame, plot a trend, pivot a table — you either write throwaway debug code or restart the whole script.

Jupyter Notebook exists to eliminate that friction. It's an interactive, cell-based environment where you can mix code, Markdown notes, and visualizations in a single document. Instead of "edit → run → forget," you get "explore → annotate → reuse." The notebook becomes your analysis lab bench: every experiment leaves a trace, every conclusion has evidence, and every collaborator can follow your reasoning.

By the end of this lesson, you'll be able to set up Jupyter Notebook for analysis from scratch, organize your workspace, and run a complete exploratory workflow — the foundation for every lesson that follows in this track.

Core concept / mental model

Think of a Jupyter notebook as a scientist's lab notebook — but for data. Each cell is a single experiment: a short block of code (or formatted text) that you run independently. The kernel (the Python engine behind the scenes) remembers everything from earlier cells, so you can build an analysis step by step without re-running the whole script.

A notebook file (.ipynb) is just structured JSON, but you'll rarely look under the hood. What matters is the interactive workflow:

• Code cells execute Python and show output right below.
• Markdown cells let you write headings, explanations, and even LaTeX math.
• The kernel keeps variables alive across cells, so you can explore incrementally.
• Outputs — text, tables, charts — are stored with the code, making the notebook a reproducible record.

Here's the mental model in one breath: a notebook is a sequence of instructions + context + results, all in one place. When you open a notebook months later, you see exactly what you did and why.

Pro tip: The kernel runs in a separate process from the browser interface. If your code hangs, you can interrupt or restart the kernel without losing your notebook file.

How it works step by step

Setting up Jupyter Notebook for analysis involves three layers: installation, launching, and configuration for your project. Here's the logical sequence:

1. Install Jupyter

You need a Python environment first. If you're using Anaconda, Jupyter comes bundled. Otherwise, install with pip:

pip install jupyter

This installs the notebook server, kernel, and core utilities. For a cleaner setup, create a dedicated virtual environment for your data projects.

2. Launch the notebook server

Navigate to your project folder and run:

jupyter notebook

Your default browser opens a dashboard showing the files in that directory. You can also use jupyter lab for a more IDE-like interface.

3. Create a notebook

Click New → Python 3 to create a notebook. You'll get a single empty code cell. Start by importing your core libraries:

import pandas as pd
import matplotlib.pyplot as plt

4. Configure for reproducibility

Set a few preferences to make your analysis trustworthy:

• Always show plots inline with %matplotlib inline.
• Set a fixed random seed if you use randomness.
• Keep notebook and data in the same folder to use relative paths.

5. Save and share

Use File → Save and Checkpoint to create a checkpoint — a snapshot you can roll back to. When you're done, export to HTML or PDF via File → Download as.

Hands-on walkthrough

Let's run a complete example: loading a CSV, exploring it, and plotting a quick trend. This mirrors the kind of analysis you'll build throughout this track.

First, create a sample dataset. In a new cell, run:

import pandas as pd

# Create a simple dataset
sales = pd.DataFrame({
    'month': ['Jan', 'Feb', 'Mar', 'Apr', 'May'],
    'revenue': [120, 150, 130, 180, 200]
})

print(sales.head())

Output:

  month  revenue
0   Jan      120
1   Feb      150
2   Mar      130
3   Apr      180
4   May      200

Now add a Markdown cell (change the cell type to Markdown) and write:

## Sales trend analysis

This notebook analyzes monthly revenue data.

Then create a plot in a new code cell:

import matplotlib.pyplot as plt

plt.figure(figsize=(6,4))
plt.plot(sales['month'], sales['revenue'], marker='o')
plt.title('Monthly Revenue')
plt.xlabel('Month')
plt.ylabel('Revenue ($)')
plt.grid(True)
plt.show()

Output: A line chart appears inline — no extra window needed.

Now test the kernel's memory. In a new cell, type:

# Variables persist across cells
final_revenue = sales['revenue'].sum()
print(f"Total revenue: ${final_revenue}")

Output:

Total revenue: $780

Finally, save a checkpoint (File → Save and Checkpoint) and keep going. Your notebook is now a clean, interactive analysis environment.

Compare options / when to choose what

You have several ways to run Jupyter Notebook. Here's how they stack up:

Which should you choose?

For this track, Jupyter Notebook or Jupyter Lab — whichever your environment has — is the right default. If you're already using VS Code, the built-in notebook support is a smooth pivot. Google Colab is great for quick experiments, but you'll want a local setup for serious work.

Pro tip: Once you're comfortable, try Jupyter Lab — it lets you drag a plot and a DataFrame view side by side, which is a game changer for exploration.

Troubleshooting & edge cases

Even a smooth setup can hit snags. Here are the common ones and how to fix them:

jupyter: command not found

Your Python environment isn't on your PATH. Activate your virtual environment first, or install Jupyter in the same environment you're using.

Notebook opens, but Python code won't run

The kernel might be disconnected. Go to Kernel → Restart & Run All to reset and execute every cell in order. If that fails, restart the kernel from scratch.

Plots don't show inline

Make sure you ran %matplotlib inline in a cell before your plotting code. If you're in Jupyter Lab, use %matplotlib widget for interactive plots.

Variables disappear after restart

That's expected — the kernel resets all memory. If you need to keep data, re-run the notebooks in order, or save processed data to a CSV with df.to_csv('clean_data.csv').

Permission errors on save

On some systems, the notebook server can't write to your project folder. Check folder permissions or move the notebook to your home directory.

Kernel dies after heavy computation

Increase available memory (if using Docker or VS Code), or chunk your data processing. For pandas, use dtype parameters to reduce memory usage.

What you learned & what's next

You now know how to set up Jupyter Notebook for analysis: install it, launch a server, create notebooks, mix code and Markdown, and troubleshoot common issues. You can explain the core idea behind interactive notebooks and complete a practical exercise — from loading data to plotting a chart — all in a reproducible format.

This is the sandbox for every lesson that follows in the Data Science with Python track. From here, we'll dive deeper into data manipulation with pandas, cleaning messy datasets, and creating visualizations with Matplotlib & Seaborn. With your notebook ready, you're set to turn raw data into actionable insights — step by step.

Remember: a notebook is not just code — it's your analysis narrative. Keep it tidy, annotate your decisions, and you'll build analyses you can trust and share.