Jupyter Notebooks
Let's take a look at the software tools you'll be relying on throughout this primer, since getting comfortable with them now will make everything that follows considerably smoother. The vast majority of practical exercises in this course will be carried out using Jupyter Notebooks, a versatile, interactive environment that allows explanatory text, executable Python code, mathematical equations, and data visualisations to all live together within a single, shareable document. This format makes it particularly well suited to learning, since you can read an explanation, run the corresponding code immediately below it, and see the output right there, all without switching between separate tools, windows, or applications. It also means that as you progress through the primer, you'll be able to revisit earlier notebooks at any time, rerun the code, and refresh your understanding of a concept simply by reading through the mix of text and working examples.
By the end of this primer, you will have installed the Anaconda distribution, a popular software package that bundles Python together with Jupyter Notebooks and a wide range of commonly used libraries for tasks such as data analysis and visualisation, saving you the considerable trouble of installing and configuring each component separately. Alongside this, you'll also have learned a set of practical, hands-on skills: creating new notebooks from scratch, saving your work as you go, opening existing notebooks, and managing them effectively, including organising them into folders for different topics or projects, and navigating comfortably between cells of code and explanatory text within a single notebook. These foundational skills will underpin every subsequent programming activity in this course, so it's well worth taking the time now to get comfortable with them, rather than rushing ahead, since a solid grasp of the tools will make it far easier to focus on the programming concepts themselves later on.
Watch video: Setting Up Anaconda and Jupyter Notebooks
What is Anaconda?
Anaconda is a comprehensive software distribution that bundles Python together with a large collection of the libraries most commonly relied upon for scientific computing, data analysis, machine learning, and visualisation, sparing users the effort of tracking down and installing each one individually. Beyond simply providing these packages, Anaconda also includes tools for creating and managing separate programming environments, which allow different projects to use different versions of Python or specific libraries without conflicting with one another. It also comes with Anaconda Navigator, a graphical interface that makes it easy to launch tools such as Jupyter Notebooks without needing to rely on the command line, making the whole setup especially convenient for beginners getting started with Python.
What is a Jupyter Notebook?
A Jupyter Notebook is an interactive document that weaves together formatted text, executable Python code, code outputs, figures, and mathematical equations, all within a single file. This structure makes it an excellent environment for learning to program, since explanations and working code sit side by side, for documenting analyses in a clear, step-by-step narrative, and for sharing computational work with others in a form that's easy to follow and reproduce. Notebooks are organised into individual cells, which can be run independently and in any order you choose, allowing you to experiment, revise, and rerun specific sections of code without having to execute the entire document from start to finish each time.
Software Versions
Please note that the appearance of the Anaconda and Jupyter interfaces you encounter may differ somewhat from what's shown in the accompanying video. Software of this kind is updated on a fairly regular basis, so it's not unusual for menu layouts, icons, or button placements to shift slightly between versions. Even so, the underlying functionality remains consistent throughout, so if something doesn't appear exactly where the video shows it, it's usually just a matter of checking an alternative menu, toolbar, or settings panel rather than a sign that the feature has been removed. If you do get stuck locating something, it's often worth searching the specific version's documentation or support resources for guidance.
Using Jupyter Notebooks
The goal of this activity is to help you become comfortable navigating the Jupyter Notebook interface as provided through the Anaconda distribution. Over the course of this activity, you'll learn to move around the notebook environment with confidence, understanding where key menus, toolbars, and controls are located, and you'll come to appreciate the key features, such as cells, kernels, and markdown formatting, that make Jupyter such an effective platform for programming, data analysis, and clear, well-documented technical writing. By the end, you should feel comfortable enough with the interface to focus your attention on the programming concepts themselves, rather than on figuring out the tool.
The Jupyter Interface
The Jupyter Notebook interface offers a flexible workspace in which you can create, edit, rename, and organise your notebooks, whether that's grouping them into folders or arranging them in whatever structure suits your workflow. Within this workspace, you'll find menus and toolbars that give you quick access to common actions, such as saving your work, adding or deleting cells, and running code, alongside interactive cells where you can write and execute code, add explanatory text, and view results, all within one unified environment. This tight integration of writing, running, and documenting means you rarely need to leave the notebook to accomplish a task, which is a big part of what makes Jupyter such an efficient tool for both learning and everyday practical work.
Notebook Features
A notebook brings together formatted text, executable Python code, graphical outputs, mathematical equations, and visualisations within a single, cohesive document. The formatted text is typically written using Markdown, allowing you to add headings, bullet points, bold or italic emphasis, hyperlinks, and even embedded images to explain your work in plain language. The code cells sit alongside this text and can be run individually, producing outputs directly beneath them, whether that's a simple printed value, a data table, an error message, or a rendered chart such as a line graph, histogram, or scatter plot generated using a library like Matplotlib or Seaborn. Mathematical equations can be included using LaTeX notation, making it possible to display anything from a simple formula to a more complex statistical model directly within the text, rendered cleanly rather than as plain characters.
This integrated format is particularly well suited to several kinds of work. For learning, since a concept can be explained in text immediately followed by a working code example the student can run, modify, and re-run to see how the output changes. For experimentation, since a data scientist might test several approaches to cleaning a dataset in adjacent cells, comparing outputs without needing to rerun an entire script from scratch. For reproducible research, since a colleague or reviewer can open the same notebook, follow the exact sequence of steps, and reproduce a published result rather than having to guess at code that was used but not shown. And for communicating analytical work more broadly, for example, a financial analyst preparing a notebook that walks through a company's quarterly figures, complete with charts and a written summary, so that a non-technical reader can follow the reasoning, the underlying code, and the final conclusion in one continuous narrative, rather than piecing it together from separate spreadsheets, scripts, and slide decks.
Why Use Jupyter?
Jupyter Notebooks provide immediate feedback when code is executed, since running a cell displays its output right beneath it, whether that's a number, a table of data, an error traceback, or a chart, without needing to run the entire program from start to finish. This encourages a style of working where programs are built up incrementally: a user might write a few lines to load a dataset, run that cell to confirm it worked, then add another cell to clean the data, run that, and continue building the program step by step rather than writing the whole thing blindly and hoping it works. This same structure makes notebooks ideal for testing ideas interactively, for instance, quickly trying out a few different ways to filter a dataset or tweak a formula, comparing the results side by side without having to rewrite or rerun unrelated parts of the code.
Because text and code sit together, users can also document their reasoning as they go, explaining why a particular approach was chosen, what a result means, or what to watch out for, directly alongside the relevant code rather than in a separate report. This combination of interactivity, incremental development, and built-in documentation is why Jupyter Notebooks have become so widely used for Python programming across education, where students can learn by experimenting directly with runnable examples; research, where scientists and analysts use them to explore data and share reproducible findings; and industry, where they're commonly used for prototyping machine learning models, exploring datasets, and communicating results to both technical and non-technical colleagues.