How to Use Jupyter: The Beginner's Guide (First Notebook, First Cell, Kernels, and the Save-Before-You-Close Rule)
CodexFuse Team · 2026-10-28T21:17:27.237Z · 15 min read
Learning how to use Jupyter takes about an hour: install it with pip or Anaconda, open your first notebook, run code and Markdown cells, pick a kernel, and save and share your work.
Learning how to use Jupyter takes about an hour, and most of that hour is spent doing the steps once, slowly, instead of reading about them. Jupyter Notebook is an open-source web application that combines live code, equations, visualizations, and narrative text in a single shareable document. You write code in small blocks called cells, run each block on its own, and see the result right underneath it. This guide takes you from a blank install to your first notebook, your first plot, and a file you can share — the three moves that make up almost everything beginners do with Jupyter. The steps were checked against Project Jupyter's own install documentation and current beginner guides on October 28, 2026.
This guide is written for Jupyter beginners: students, analysts, and new data-science learners who want to run Python code piece by piece instead of writing a whole script blind. You do not need to know the command line well, and you do not need to pay for anything. If you already edit code in an editor, our VS Code beginner guide covers the editor most Jupyter users graduate to — Jupyter itself runs in your browser, so the two tools complement each other rather than compete.
How Do You Use Jupyter?
You use Jupyter by installing it, launching it from a terminal, creating a notebook, and running code one cell at a time. A notebook is a document made of cells, and each cell is either code that runs or Markdown text that explains. A kernel — the process that executes your code — sits behind the notebook and remembers every variable you have created. The whole first session looks like this:
- Install Jupyter with
pip install notebookfor the classic Notebook, orpip install jupyterlabfor JupyterLab. - Launch it with
jupyter notebookorjupyter lab, which opens the interface in your default browser. - Create a notebook by choosing Python 3 from the New menu, then rename it from Untitled to something meaningful.
- Write code in a cell and press Shift+Enter to run it and move to the next cell.
- Add Markdown cells to explain what each block of code does, so the notebook reads like a report.
- Save before you close, then share the .ipynb file or export it as HTML for readers without Jupyter.
That is the entire loop. The rest of this guide slows each step down, explains the two ideas that confuse every beginner — cells versus kernels, and Notebook versus JupyterLab — and shows the mistakes to avoid in your first week.
What Is Jupyter Notebook, and How Is It Different From JupyterLab?
Jupyter Notebook is the classic single-document interface: one notebook open in one browser tab, with a file list to move between documents. JupyterLab is the newer, multi-panel workbench from the same project, and current Notebook 7 installs are built on JupyterLab under the hood. Both read and write the same .ipynb notebook files, so choosing one does not lock your work into the other. The practical difference is the workspace around the notebook, not the notebook itself.
JupyterLab adds a file browser, a terminal, and a text editor alongside your notebooks, so you can edit a data file, run a shell command, and view a CSV without leaving the browser tab. The classic Notebook keeps things simpler: a dashboard of files and folders, and one notebook at a time. Beginners who only want to learn Python should start with the classic Notebook, because there is less interface to learn. Beginners who already juggle files, terminals, and scripts will feel at home in JupyterLab immediately.
Google Colab is the third option in the same family, and it matters because it needs no install at all. Colab runs notebooks in the browser on Google's servers, which makes it the fastest way to try a notebook on a borrowed computer. The trade-off is that your code runs on someone else's machine, with session limits and a Google account attached. For learning, Colab is a fine front door; for regular work, a local install is the habit that scales.
| Option | Best for | Install needed | What you get |
|---|---|---|---|
| Jupyter Notebook | First-time learners | Yes, pip or Anaconda | One notebook per tab, simple file dashboard |
| JupyterLab | Everyday data work | Yes, pip or conda-forge | Notebooks plus file browser, terminal, and editor in one tab |
| Google Colab | Trying notebooks with zero setup | No, runs in the browser | Hosted notebooks, session limits, Google account required |
How Do You Install Jupyter?
You install Jupyter with pip if you already have Python, or with Anaconda if you want Python and Jupyter bundled together. Project Jupyter's own install page recommends pip as the installation tool, and it lists the two commands that cover nearly every beginner. Before either command, check that Python is installed by running python --version in your terminal. If that prints a Python 3 version, you are ready.
For the classic Notebook, run pip install notebook and then launch it with jupyter notebook. For JupyterLab, run pip install jupyterlab and launch it with jupyter lab. Both commands start a small server on your own computer and open the interface in your default browser. The server runs locally only, so your notebooks and data never leave your machine unless you choose to share them.
Anaconda is the alternative path, and it suits beginners who do not yet have Python installed at all. Installing Anaconda gives you Python, Jupyter, and the common data libraries in one download, and Jupyter comes bundled with it. The conda route for JupyterLab uses the conda-forge channel: conda install -c conda-forge jupyterlab. Pick one path and stick with it for your first month, because mixing pip and conda installs in the same environment is the most common source of "command not found" confusion.
| Route | Install command | Launch command | Choose it if |
|---|---|---|---|
| pip, Notebook | pip install notebook | jupyter notebook | You have Python and want the simplest interface |
| pip, JupyterLab | pip install jupyterlab | jupyter lab | You want the multi-panel workbench |
| conda-forge, JupyterLab | conda install -c conda-forge jupyterlab | jupyter lab | You manage environments with conda or mamba |
| Anaconda bundle | Install Anaconda itself | jupyter notebook | You need Python and Jupyter together, from scratch |
If the terminal answers "command not found" after installing, the usual cause is a PATH problem, not a failed install. Installing with pip install --user puts the launcher in your user-level bin folder, which must be on your PATH before the shell can find it. Close and reopen the terminal after installing, and try again before reinstalling anything. A fresh terminal picks up PATH changes that the old one cannot see.
How Do You Create Your First Notebook?
You create your first notebook by launching Jupyter, opening the folder you want to work in, and choosing Python 3 from the New menu. Start in a dedicated folder for the project, so notebooks, data files, and exports stay together instead of scattering across your home directory. From that folder, run jupyter notebook and wait for the browser tab to open on the dashboard.
On the dashboard, click New and then Python 3. Jupyter creates a notebook called Untitled.ipynb and opens it with one empty code cell. Rename it right away through File and Rename, because a folder full of Untitled notebooks is unsearchable a week later. A name like first-analysis.ipynb tells future you exactly what is inside.
The .ipynb extension is the notebook format itself: one JSON file holding your code cells, your Markdown text, and your outputs together. That single-file design is why a notebook is so easy to share and so easy to lose track of. Keep one notebook per question you are answering, and give each one a name that states the question.
What Are Cells, and How Do You Run Them?
A cell is one block of a notebook, and every cell has a type: Code, Markdown, or Raw. Code cells hold code that the kernel runs, and their output appears directly underneath them. Markdown cells hold formatted text — headings, explanations, links, and images — and they are what turn a script into a readable document. Raw cells hold unformatted text that Jupyter leaves alone, and beginners can ignore them until a template or export asks for them.
Running a cell is deliberately simple. Click inside a code cell, type your code, and press Shift+Enter to run it and move to the next cell. The bracket on the left of the cell shows an asterisk while the code is running, and it turns into a number once the run finishes. That number is the order the cell ran in, not its position in the document, and the distinction matters: you can run cells in any order, and the numbers will tell you the truth about what actually happened.
Cells also have two modes, and the border color tells you which one you are in. A green border means edit mode, where typing goes into the cell; a blue border means command mode, where keystrokes act on the cell itself. Press Enter to enter edit mode, and press Esc to return to command mode. Alt+Enter runs a cell and inserts a new empty cell below it, which is the fastest way to keep writing without reaching for the mouse.
| Cell type | What goes in it | What happens when you run it |
|---|---|---|
| Code | Python code, one or more lines | The kernel runs it; output appears below the cell |
| Markdown | Headings, explanations, links, images | It renders as formatted text in the document |
| Raw | Unformatted text, left untouched | Nothing runs; the text passes through to exports |
| Shortcut | What it does | When to use it |
|---|---|---|
| Shift+Enter | Runs the cell, moves to the next one | Your everyday run command |
| Alt+Enter | Runs the cell, inserts a new cell below | When you are writing a notebook top to bottom |
| Enter | Enters edit mode on the selected cell | When the border is blue and you want to type |
| Esc | Returns to command mode | When the border is green and you want cell commands |
What Is a Kernel, and When Do You Change It?
A kernel is the process that executes your code, and each notebook is bound to one kernel at a time. When you create a Python 3 notebook, you are really creating a document attached to a Python kernel, and that kernel remembers every variable, import, and function you define. Cells share that memory, which is why a variable defined in cell 2 is available in cell 20. It is also why a notebook can behave strangely after cells have been run out of order: the kernel's memory reflects the order cells ran in, not the order they appear on the page.
You change kernels when the language or environment changes, not when the code gets hard. A notebook that analyzes data with Python uses a Python kernel, and a notebook that needs R or Julia needs that language's kernel instead. In JupyterLab and Notebook 7, the kernel picker sits at the top right of the notebook, and switching kernels starts a fresh session. Your cells stay, but the kernel's memory resets, so variables from the old kernel are gone.
When a cell seems stuck, the kernel is the first thing to check. An asterisk that never turns into a number means the kernel is still working, or waiting on something that will never finish. The Kernel menu lets you interrupt the run, or restart the kernel entirely and start from a clean state. Restarting is not a failure: experienced notebook users restart and run all cells, top to bottom, before they trust or share any result. That single habit catches most out-of-order mistakes.
Your First Real Notebook: A Worked Example
The fastest way to learn Jupyter is to build one small notebook that answers one real question, and this section does exactly that. The question is simple: four quiz scores are 12, 18, 24, and 30, and what are their total, their average, and each score squared? The notebook below has three cells — one Markdown heading, one code cell that computes the answers, and one Markdown cell that states them in plain language. Every number in it is computed, not typed, so the notebook stays correct if the scores change.
Start with a Markdown cell that states the question in one line: "Four quiz scores: 12, 18, 24, 30. What are the total, the average, and the squares?" Then add a code cell with the following lines, and run it with Shift+Enter. The kernel adds the four numbers to 84, divides by 4 to get 21.0, and squares each score to 144, 324, 576, and 900.
scores = [12, 18, 24, 30]
total = sum(scores)
average = total / len(scores)
squares = [s ** 2 for s in scores]
print(total, average, squares)The output under the cell reads 84 21.0 [144, 324, 576, 900], and each figure can be checked by hand in seconds. The total is 12 + 18 + 24 + 30 = 84, the average is 84 / 4 = 21.0, and the squares are 144, 324, 576, and 900. Finish with a Markdown cell that writes the conclusion in words: "The four scores total 84, average 21.0, and square to 144, 324, 576, and 900." A notebook that ends with its conclusion in plain language is one a reader can trust without rerunning a line.
That three-cell pattern — question, computation, conclusion — scales to real analysis without changing shape. A data notebook swaps the score list for a loaded dataset, adds a chart cell that plots the values, and keeps the same Markdown frame around it. If your notebook will call a web API for its data, test the endpoint first with our Postman beginner guide before wiring the request into a cell. Debugging an API inside a notebook is painful; debugging it in a dedicated API tool first is quick.
How Do You Save, Share, and Export a Notebook?
You save a notebook by letting Jupyter's automatic checkpoints do their job, and by saving deliberately before you close. Jupyter saves the notebook with checkpoints as you work, and it warns you if you try to leave with unsaved changes. The safe closing sequence is to save, then use File and Close and Halt, which closes the notebook and stops its kernel. Closing the browser tab alone leaves the kernel running, which is harmless for one notebook but wasteful across a dozen forgotten tabs.
Sharing the .ipynb file itself is the simplest option when the reader also uses Jupyter, because they get your code, text, and outputs together. For everyone else, export to HTML: in the classic Notebook, use File and Download as and choose HTML, and in JupyterLab, use File and Save and Export Notebook As and choose HTML. The HTML file opens in any browser, shows every output and chart, and needs no Jupyter install to read. That makes HTML the right format for reports, assignments, and stakeholders.
For batch work, the command-line tool nbconvert does the same job without opening the interface: jupyter nbconvert --to html notebook.ipynb writes an HTML file next to the notebook. PDF export follows the same pattern, but it needs a LaTeX install on your machine, which is a large download for a first-week task. Start with HTML, and add PDF only when a reader specifically asks for a print-ready document. If you keep notebooks in a shared project, put them under version control with our GitHub beginner guide — a notebook is a file like any other, and Git tracks every change to it.
Mistakes Beginners Make in the First Week
The most common beginner mistake is running cells out of order and trusting the result. Because the kernel remembers variables in run order, a cell that worked five minutes ago can fail after you rerun an earlier cell that redefined its inputs. When a notebook starts behaving oddly, restart the kernel and run all cells from the top. If the result changes, the notebook had an order problem, not a code problem.
The second mistake is closing the browser tab without saving, and assuming the tab will remember everything. Jupyter's checkpoints protect most work, but the only save you can be certain of is the one you make before closing. The third mistake is installing Jupyter three different ways — pip, conda, and Anaconda — and then wondering which install the jupyter command actually launches. One install route, one environment, and a fresh terminal after installing will prevent most of this confusion.
The fourth mistake is sharing a notebook that was never run top to bottom. A notebook with stale outputs tells a story its code no longer supports, and the reader has no way to tell. Restart, run all, check that every output matches its cell, and only then share. That five-minute check is the difference between a notebook that teaches and a notebook that misleads.
When Should You Move From Notebook to JupyterLab?
You should move to JupyterLab when the work around the notebook starts taking more time than the notebook itself. If you regularly switch between a notebook, a data file, a terminal, and a script, JupyterLab puts all four in one browser tab with a shared file browser. If you only ever open one notebook at a time, the classic Notebook is still the right tool, and there is no penalty for staying.
Nothing is lost in the move, because both interfaces read the same .ipynb files. A notebook created in the classic interface opens unchanged in JupyterLab, and the reverse is equally true. That is the practical meaning of current Notebook 7 being built on JupyterLab: the two are views onto the same documents, not rival formats. Start simple, move when the workspace earns it, and keep your notebooks in one project folder either way.
Running Jupyter on a remote machine is the natural next step once local notebooks feel small, and the same server idea applies. Our what is VPS hosting guide explains the server side in plain language, for the day a dataset outgrows your laptop's memory. Until then, a local install, a clean project folder, and the restart-and-run-all habit will carry a beginner further than any advanced feature.
Sources
- Project Jupyter — Installing Jupyter (pip install commands for JupyterLab and Notebook, launch commands, conda-forge note)
- Guru99 — Jupyter Notebook Tutorial (Notebook 7 built on JupyterLab, pip install notebook, first-notebook steps, edit/command modes, Shift+Enter and Alt+Enter, Close and Halt, checkpoints)
- JupyterLab 4.2 Documentation — Installation (conda, mamba, pip, pipenv and Docker install routes, terminal-launched browser application)
- daily.dev — Jupyter for Beginners (JupyterLab as the fancier version with terminal, text editor, and data viewer built in; code, Markdown, kernel, and dashboard basics)
- Data Carpentry — Overview of Jupyter Notebooks (local server plus browser client, code and Markdown cells, Shift+Return to run)
- ML Journey — Exporting Jupyter Notebook Outputs (File, Download As, HTML export; nbconvert command-line export)
- CopyProgramming — Download a Jupyter Notebook Guide (HTML as the best format for readers without Jupyter; nbconvert formats; PDF export needs LaTeX)
Frequently Asked Questions
Do I need Python installed before I install Jupyter?
Yes, unless you install the Anaconda bundle, which includes Python. The pip route assumes Python 3 is already on your machine, and you can confirm it with python --version. Anaconda suits beginners starting from nothing, because it installs Python, Jupyter, and the common data libraries together.
Should a beginner start with Jupyter Notebook or JupyterLab?
Start with the classic Notebook if you only want to learn Python, because its interface is smaller and every step in this guide matches it. Move to JupyterLab when you start juggling files, terminals, and scripts alongside notebooks. Both read the same .ipynb files, so switching later costs nothing.
Can I use Jupyter without installing anything?
Yes, through a hosted notebook service that runs notebooks in the browser, such as Google Colab. That is the fastest way to try a notebook on a computer you do not own. For regular work, a local install is better, because your files stay on your machine and no session can time out on you.
Why is my cell stuck on an asterisk?
The asterisk means the kernel is still running that cell, or waiting on something that will not finish. Wait a few seconds for a slow computation, then interrupt the kernel from the Kernel menu if it stays stuck. If the notebook keeps misbehaving after that, restart the kernel and run all cells from the top.
How do I share a notebook with someone who does not have Jupyter?
Export it as HTML, which opens in any browser and shows every output and chart without a Jupyter install. Use File and Download as in the classic Notebook, or File and Save and Export Notebook As in JupyterLab. Send the .ipynb file itself only to readers who use Jupyter.