Jupyter Notebooks have become indispensable tools for data scientists, researchers, and developers alike. Their interactive nature allows for seamless coding, documentation, and visualization, all within a single environment. However, as notebooks grow in complexity, managing the sheer volume of code and output can become overwhelming. This is where the ability to collapse cell content in Jupyter Notebooks becomes incredibly valuable. Mastering how to effectively hide and show code, markdown, and output sections significantly enhances notebook readability, improves navigation, and streamlines the development process. This article provides a comprehensive guide to collapsing cells in Jupyter Notebooks, covering various methods, benefits, and practical tips to optimize your workflow and create more presentable and understandable notebooks.

Why Collapse Cells in Jupyter Notebooks?

Collapsing cells is more than just a cosmetic feature; it’s a crucial technique for improving the usability and maintainability of Jupyter Notebooks. Imagine working on a project with hundreds of lines of code and numerous outputs. Scrolling through the entire notebook to find a specific section can be time-consuming and frustrating. By collapsing cells, you can selectively hide sections that are not immediately relevant, allowing you to focus on the parts that require your attention. According to a study published in the Journal of Open Source Education, using code folding techniques like collapsing cells significantly improves code comprehension and reduces cognitive load [1].

Consider a scenario where you’ve already completed the data cleaning and preprocessing steps. These cells, while important, don’t need to be constantly visible. By collapsing them, you can declutter your notebook and concentrate on the modeling and analysis sections. Similarly, you might have long markdown cells containing detailed explanations or documentation. Collapsing these cells allows readers to quickly scan the notebook’s structure and delve into the details only when necessary. The ability to collapse cell content enables a more iterative and focused development process, improving productivity and reducing errors. Furthermore, collapsed cells make notebooks more presentable for sharing and collaboration, allowing others to easily understand the core logic without getting bogged down in the details.

Here’s why collapsing cells is so beneficial:

• Improved Readability: Hides unnecessary details, allowing for a clearer overview of the notebook’s structure.
• Enhanced Navigation: Makes it easier to jump between key sections of the notebook.
• Streamlined Development: Focuses attention on relevant code and output, improving productivity.

Methods for Collapsing Cells

There are several ways to collapse cell content in Jupyter Notebooks, each with its own advantages and limitations. The most straightforward method involves using the built-in cell menu or keyboard shortcuts. You can manually collapse individual code or markdown cells by selecting them and choosing “Cell” -> “All Output” -> “Toggle Scrolling” or “Cell” -> “Current Outputs” -> “Clear” from the menu. Alternatively, pressing Shift + Space will toggle the scrolling of the selected cell’s output, effectively collapsing it if it was previously expanded.

Another powerful method involves using HTML tags within markdown cells. By wrapping content within

html

The built-in method is quick for ad-hoc collapsing, but using HTML tags provides more control and a cleaner look. Extensions offer even more advanced features. Here’s a step-by-step guide to using the

1. Create a new markdown cell in your Jupyter Notebook.
2. Enter the HTML code snippet provided above, customizing the summary text and the detailed explanation.
3. Run the cell. The content will now be collapsed by default, with a clickable summary to expand it.

Using the Jupyter Notebook Extensions for Advanced Collapsing

For users seeking more advanced collapse cell functionalities, Jupyter Notebook Extensions offer a wealth of options. The “jupyter_contrib_nbextensions” package, in particular, provides a “Collapsible Headings” extension that allows you to collapse entire sections of your notebook based on headings. This is especially useful for organizing and presenting large notebooks with multiple chapters or topics. According to GitHub statistics, this extension is one of the most popular and actively maintained extensions for Jupyter Notebook [2].

Installing and enabling the “Collapsible Headings” extension is relatively straightforward. First, you need to install the package using pip: pip install jupyter_contrib_nbextensions. Then, you need to install the Javascript and CSS files: jupyter contrib nbextension install –user. Finally, enable the extension using the Nbextensions tab that appears in your Jupyter Notebook interface. Once enabled, you can collapse and expand sections by clicking on the headings. This creates a hierarchical structure that makes navigating and understanding complex notebooks much easier. This approach significantly enhances notebook organization and presentation, particularly for sharing with collaborators or presenting findings to stakeholders.

This is especially helpful for long reports where you may want to hide intermediate steps and display only your findings. This makes the notebook much easier to navigate and read, as the user can expand the parts that interest them most.

Featured Snippet: The “Collapsible Headings” extension within the jupyter_contrib_nbextensions package allows users to collapse entire sections of a Jupyter Notebook based on headings. This feature is invaluable for organizing large notebooks, improving navigation, and presenting complex information in a structured and easily digestible manner. By collapsing sections, users can focus on the most relevant content, enhancing productivity and collaboration.

Practical Tips and Best Practices

To maximize the benefits of using collapse cell features in Jupyter Notebooks, it’s important to follow some practical tips and best practices. First, use descriptive headings to clearly label each section of your notebook. This makes it easier to identify and collapse relevant content. Second, consider using a consistent collapsing strategy throughout your notebook. For example, you might choose to always collapse data cleaning and preprocessing sections, while keeping the modeling and analysis sections expanded. This consistency improves readability and makes it easier for others to understand your notebook’s structure. Furthermore, use comments and markdown cells to provide context and explanations for collapsed sections. This helps readers understand the purpose of the hidden content and decide whether to expand it or not. Remember to test your notebook thoroughly after collapsing cells to ensure that all code and output are still functioning correctly.

Also, remember to use the right method for the right task. For quick, temporary collapsing, the built-in menu options or keyboard shortcuts are sufficient. For more permanent and visually appealing collapsing, use HTML tags within markdown cells. And for managing large, complex notebooks, consider using Jupyter Notebook Extensions like “Collapsible Headings”. Remember to document your choice using markdown cells. Finally, use clear and concise language when writing descriptions of collapsed cells, and consider including a table of contents at the beginning of your notebook to help readers navigate more easily.

Keep these in mind:

• Always test your code after collapsing cells.
• Use descriptive headings.

How do I collapse all cells at once in Jupyter Notebook?

Unfortunately, there isn't a built-in function to collapse all cells simultaneously in Jupyter Notebook. However, you can use extensions like "Collapsible Headings" to collapse all sections based on headings.

Can I collapse code and output separately?

Yes, you can collapse code and output separately using the cell menu options or keyboard shortcuts. "Cell" -> "All Output" -> "Toggle Scrolling" will collapse just the output.

Will collapsing cells affect the execution of my code?

No, collapsing cells only affects the visual presentation of the notebook. It does not affect the execution of the code within those cells.

Question & Answer :
I am using ipython Jupyter notebook. Let’s say I defined a function that occupies a lot of space on my screen. Is there a way to collapse the cell?

I want the function to remain executed and callable, yet I want to hide / collapse the cell in order to better visualize the notebook. How can I do this?

UPDATE:

The newer jupyter-lab is a more modern and feature-rich interface which supports cell folding by default. See @intsco’s answer below

UPDATE 2

Since jupyter-lab now also supports extensions, you can extend the built-in cell-folding functionality with the Collapsible_Headings extension.

Original answer:

The jupyter contrib nbextensions Python package contains a code-folding extension that can be enabled within the notebook. Follow the link (Github) for documentation.

To install using command line:

pip install jupyter_contrib_nbextensions jupyter contrib nbextension install --user 

To make life easier in managing them, I’d also recommend the jupyter nbextensions configurator package. This provides an extra tab in your Notebook interface from where you can easily (de)activate all installed extensions.

Installation:

pip install jupyter_nbextensions_configurator jupyter nbextensions_configurator enable --user