Jupyter Notebook Nedir? Veri Analistleri İçin Kullanım Rehberi

What is Jupyter Notebook?

Jupyter Notebook is a working environment that brings code cells, explanatory text and execution output together in a single interactive document. The part that matters to an analyst is this: you can run code in small pieces, see the intermediate result immediately, and write down what it means in the same file. The document is stored with an .ipynb extension and holds not just the code but the tables, charts and text it produced.

The interface talks to a kernel, which is what actually runs the code. For Python that kernel is IPython. When you run a cell, the code goes to the kernel and the result comes back underneath it. The kernel keeps a session alive in the background, so a variable defined in one cell is still there in the next.

Installing and first run

Creating a separate virtual environment per project keeps package versions from colliding. In analysis projects this largely eliminates the "why doesn't this work any more?" question months later.

# virtual environment in the project folder
python -m venv .venv

# Windows PowerShell
.venv\Scripts\Activate.ps1
# macOS / Linux
source .venv/bin/activate

python -m pip install notebook pandas matplotlib

With the environment active, start the server inside the project folder. A local interface opens in the browser, and from there you can create a new Python notebook.

jupyter notebook

Cell types and execution

A notebook knows three kinds of cell. A Code cell runs code in the selected kernel. A Markdown cell produces headings, lists, links, bold text and mathematical expressions. A Raw cell is left unprocessed; it is used to carry verbatim content through certain export pipelines.

One detail deserves attention here: the visible order of cells and the order they were executed in do not have to match. The number in square brackets next to a cell shows its execution position. If it does not read 1, 2, 3 from top to bottom, the document may not produce the same result on somebody else's machine.

Narrate the analysis with Markdown

Markdown cells are what turn a notebook from a list of commands into a report. A practical layout: before the code, say what you are about to do and on what assumption; after the code, say what the result means. Three lines of explanation are the most valuable note you will ever write to your future self.

# Monthly sales analysis

We derive the monthly revenue trend from order records.

## Questions
- How does revenue change month to month?
- Which products carry the most volume?

## Definitions
Revenue = quantity × unit price. Return rows are excluded.

Headings double as navigation: in a long notebook, sections separated by ## are listed in the table-of-contents panel and make moving around far easier.

An analysis flow end to end

The typical flow has four steps: load the data, check its quality, summarise it, then draw the chart the question calls for. The example below computes monthly revenue from CSV order records.

import pandas as pd

df = pd.read_csv("data/orders.csv", parse_dates=["date"])

display(df.head())
print(df.shape)
display(df.dtypes)
display(df.isna().sum())

These four lines are the step that saves the rest of the analysis. shape gives the row count, dtypes tells you whether the date was really parsed as a date, and isna().sum() shows how much is missing in each column. Then ask yourself one more thing: what does a single row represent? If each row is an order line, the row count is not the order count.

import matplotlib.pyplot as plt

df["revenue"] = df["quantity"] * df["unit_price"]

monthly = (df.set_index("date")["revenue"]
             .resample("MS")
             .sum())

display(monthly.to_frame())

ax = monthly.plot(marker="o", figsize=(10, 4))
ax.set(title="Monthly revenue", xlabel="Month", ylabel="Revenue")
plt.tight_layout()
plt.show()

The chart appears as cell output right below the code. Two small habits make the work look serious: put units on the axes, and add a Markdown cell underneath saying in one sentence what you see.

Charts and rich output

Matplotlib figures appear directly as cell output, and plt.show() triggers that explicitly. pandas renders DataFrames as formatted HTML tables. If you need more interaction, libraries such as Plotly or ipywidgets can produce components that run inside the cell.

Output is saved into the file itself. That turns the document into a self-contained report, but it has two side effects: the file grows quickly, and a saved output stays there in its old form even after you change the code. Trimming large tables with head() and writing the full result to a separate file is a good middle ground.

Good notebook habits

Saving, exporting, sharing

An .ipynb file is really a JSON document: cells, outputs and kernel metadata all live inside it. That has two consequences. First, in version control (Git), output diffs produce unreadable noise, so clearing outputs before committing is a common practice. Second, when you send the file to someone, you send all of its output along with the code.

jupyter nbconvert --to html analysis.ipynb

The generated HTML shows the output stored in the file; it does not re-run any cells. So if you export without restarting and re-running first, stale results go into the report. Run it from the top once before converting, and open the HTML afterwards to look it over.

Common problems

Conclusion

The strength of Jupyter Notebook is that it makes the thinking process visible: you probe the data, write down what you see, move to the next step. That flexibility is also its biggest risk — a document with a scrambled execution order and stale output does not inspire confidence.

The practical rule is simple: keep cells small, narrate each section in a sentence, and restart the kernel and run everything before sharing. With those three habits, a notebook stops being a private scratchpad and becomes a document someone else can follow.