Notebooks

Computational notebooks provide an interactive environment for combining code, its results, and explanatory text. They are particularly well-suited for iterative tasks such as data analysis, as they allow you to test and document your work step-by-step. Features like automatic setup, immediate feedback, and the ease of experimentation make notebooks an accessible way to learn Python, especially when compared to more traditional programming approaches.

Google Colab

Google Colab is a cloud-based platform that lets you run notebooks without any local installation. This makes it useful for quickly exploring datasets or prototyping analytical workflows.

Getting Started

  • Access: Visit Google Colab and sign in with a Google account.
  • Create a New Notebook: Click “File > New Notebook.”
  • Upload an Existing Notebook: Upload a .ipynb file via “File > Upload Notebook.”

Overview

A notebook is made up of cells, which can contain either executable code or formatted text.

  • Code Cells: For Python code execution. Outputs appear below the cell.
  • Text Cells: Markdown-based cells for documentation or context.

Running Code

To run a code cell, select it and then either press Shift+Enter or click the play button. Here’s an example:

2 + 2
4

The output appears below the cell.

Another example:

x = 5
print(x)
5

Implicit Output

A handy feature of notebooks is that the value of the last expression in a code cell is automatically displayed as output:

# The value of 'x' will be displayed
x = 42
x
42

If you need to display the values of other variables, or variables that aren’t on the last line of a cell, use the print() function:

# Explicitly displaying values
x = 42
print(x)  # This will show the value of 'x'

y = x * 2
y  # Automatically displayed
42
84

Editing and Rerunning

Notebooks are designed for iterative work. You can easily update and rerun code cells to see the impact of your changes. This flexibility is a core advantage of using notebooks.

Variables and Memory State

In an active notebook session, variables defined in one cell remain available in subsequent cells. This allows later cells to build upon the work of earlier ones. While this is a powerful feature, it’s important to be aware that running cells out of sequence, or changing earlier cells without rerunning those that depend on them, can lead to confusion or errors.

How Variables Persist

As mentioned, variables you define in one cell can be accessed by other cells that are run later:

# Define a variable
city_name = "Madrid"

Once the city_name variable is defined by running its cell, other cells can use it without needing to define it again.

print("The selected city is:", city_name)
The selected city is: Madrid

If the defining cell is not run, a subsequent cell using city_name will raise an error.

Modifying Variables

If you change the value of a variable, you must rerun the cell where it’s defined to update its value in the notebook’s memory.

# Update the variable
city_name = "Barcelona"

Subsequent cells will then use the updated variable:

print("The selected city is now:", city_name)
The selected city is now: Barcelona

Execution Order and State

The order in which you execute cells is crucial as it determines the notebook’s current state. Running cells out of their logical order can lead to errors or unexpected outcomes.

To avoid such issues:

  1. Execute cells in logical order, starting from the top.
  2. Rerun dependent cells after modifying variables.
  3. Periodically use “Restart & Run All” to ensure consistency.

Execution Order Matters

The execution order directly affects the notebook’s environment. Variables, functions, and imported libraries become available only after their respective defining cells have been executed. For instance:

# Define a variable
x = 10
x
10

The x variable is now defined and available for subsequent cells:

y = x * 2
y
20

If x’s value is changed in its defining cell, dependent cells must be rerun to use the new value:

z = y + 5
z
25

The third cell will fail if the preceding cell (defining y) has not been run. Similarly, if the cell defining y is modified (e.g., y = x * 3), the cell using z must be rerun. Otherwise, z will be based on an outdated y.

Adding Text

Text cells use Markdown, which is a lightweight markup language. Markdown employs simple characters for formatting, enabling you to create headings, bold or italic text, lists, and tables. For a comprehensive guide, please refer to the linked documentation.

### Observations

This notebook _demonstrates the basics_ of using computational notebooks for interactive **coding** and **documentation**.

Tips

  • Troubleshooting Errors: Ensure all preceding cells have been run.
  • Collaborating: Share notebooks via “Share” in the top-right corner. Adjust permissions for viewing or editing.
  • Saving Progress: Regularly save your work to Google Drive via “File > Save a Copy in Drive.”
  • Restarting the Environment: Use “Runtime > Restart Runtime” to reset the notebook’s state and rerun all cells from the beginning.