How to clear Jupyter Notebook's output in all cells from the Linux terminal?

If you create a .gitattributes file, you can run a filter over certain files before they are added to git. This will leave the original file on disk as-is, but commit the "cleaned" version.

For this to work, add this to your local .git/config or global ~/.gitconfig:

[filter "strip-notebook-output"]
    clean = "jupyter nbconvert --ClearOutputPreprocessor.enabled=True --to=notebook --stdin --stdout --log-level=ERROR"

Then create a .gitattributes file in your directory with notebooks, with this content:

*.ipynb filter=strip-notebook-output

How this works:

• The attribute tells git to run the filter's clean action on each notebook file before adding it to the index (staging).
• The filter is our friend nbconvert, set up to read from stdin, write to stdout, strip the output, and only speak when it has something important to say.
• When a file is extracted from the index, the filter's smudge action is run, but this is a no-op as we did not specify it. You could run your notebook here to re-create the output (nbconvert --execute).
• Note that if the filter somehow fails, the file will be staged unconverted.

My only minor gripe with this process is that I can commit .gitattributes but I have to tell my co-workers to update their .git/config.

If you want a hackier but much faster version, try JQ:

  clean = "jq '.cells[].outputs = [] | .cells[].execution_count = null | .'"

nbstripout worked well for me.

Open the Jupyter terminal, navigate to the folder containing your notebook, and then run the following line:

nbstripout my_notebook.ipynb

Use --ClearOutputPreprocessor.enabled=True and --clear-output

Following this command:

jupyter nbconvert --ClearOutputPreprocessor.enabled=True --clear-output *.ipynb

To extend the answer from @dirkjot to resolve issue regarding sharing configuration:

Create a local .gitconfig file, rather than modifying .git/config. This makes the command that needs to be run on other machines slightly simpler. You can also create a script to run the git config command:

git config --local include.path ../.gitconfig

Note I have also changed the log level to INFO because I did want to see confirmation that the clean was running.

repo/.gitconfig

[filter "strip-notebook-output"]
    clean = "jupyter nbconvert --ClearOutputPreprocessor.enabled=True --to=notebook --stdin --stdout --log-level=INFO"

repo/.gitattributes

*.ipynb filter=strip-notebook-output

repo/git_configure.sh

git config --local include.path ../.gitconfig

Users then just need to run:

$ chmod u+x git_configure.sh
$ ./git_configure.sh

Use clean_ipynb, which not only clears notebook output but can also clean the code.

Install by pip install clean_ipynb

Run by clean_ipynb hello.ipynb

I must say I find jupyer nbconvert painfully slow for the simple job of clearing some sub-arrays and resetting some execution numbers. It’s a superior solution in maintainability because that tool is expected to be updated if there is a change in the notebook source code format. However, the alternate solution below is faster and may also be useful if you don’t have nbconvert 6.0 (I have an environment running 5.6.1 at the moment…)

A very simple jq (a sort of sed for json) script does the trick very fast:

jq 'reduce path(.cells[]|select(.cell_type == "code")) as $cell (.; setpath($cell + ["outputs"]; []) | setpath($cell + ["execution_count"]; null))' notebook.ipynb > out-notebook.ipynb

Very simply, it identifies code cells, and replaces their outputs and execution_count attributes with [] and null respectively.

jq 'del(.cells[]|select(.cell_type == "code").outputs[])' notebook.ipynb > out-notebook.ipynb

As mentioned in one of the previous answers you can use the command-line json processor jq to perform this task notably quicker than with nbconvert. A complete command for getting rid of metadata, outputs and execution counts can be found in this blog post:

jq --indent 1 \
    '
    (.cells[] | select(has("outputs")) | .outputs) = []
    | (.cells[] | select(has("execution_count")) | .execution_count) = null
    | .metadata = {"language_info": {"name":"python", "pygments_lexer": "ipython3"}}
    | .cells[].metadata = {}
    ' 01-parsing.ipynb

If desired, you could modify to just clean a specific part of the output, such as execution counts (recursively wherever they occur in the json), and then add this as a git filter:

[filter "nbstrip"]
    clean = jq --indent 1 '(.. |."execution_count"? | select(. != null)) = null'
    smudge = cat

And add the following to ~/.config/git/attributes to have the filter applied globally to all your local repos:

*.ipynb filter=nbstripout

There is also nbstripout which is made for this purpose, but it's a bit slower.

I suggest using pre-commit approach, using something like:

  - repo: local
    hooks:
      - id: jupyter-nb-clear-output
        name: jupyter-nb-clear-output
        files: \.ipynb$
        stages: [commit]
        language: python
        entry: jupyter nbconvert --ClearOutputPreprocessor.enabled=True --inplace
        additional_dependencies: ['jupyterlab']

also explained more in this blog.

Parse the json:

#LARGE Notebook Clean Make a Copy FIRST and Run this only on the COPY!!!!

import json 
filename = 'COPY_of_Huge_Notebook.ipynb' 
f = open(filename) 
large_ntbk = json.load(f) 
f.close() 
outputs = large_ntbk['cells'] 
for o in outputs:
    if 'outputs' in o:
        outputs['outputs'] = []

small = open('small.ipynb', 'w') 
json.dump(large_ntbk, small, indent = 2) 
small.close()

Here is my homebrew solution that I used from within a notebook to clear the 200MB output from another notebook:

with open('input.ipynb', 'r') as input_file, open('output.ipynb', 'w') as output_file:
    outblock=False 
    s2 = '   ],\n'
    s0 = '   "outputs": [],\n'
    s1 = '   "outputs": [\n'
    
    for line in input_file:
        if outblock:
            if line == s2:
                print(f'match{s2[:-1]}')
                outblock = False
                output_file.write(s0)
            continue     
        if line == s0:
            print(f'match{s0[:-1]}')
            output_file.write(line)
            continue
        if line == s1:
            print(f'match{s1[:-1]}')
            outblock = True
            continue
        output_file.write(line)

A function inspired by preceding answers that can be called on a list of files.

import json

def ntbk_clean(nb_path):  <==== pass in file path

    with open(nb_path, 'rb') as f:   <==== open the file
        notebook = json.load(f)
        outputs = notebook['cells']   <==== body of notebook

    for index, o in enumerate(outputs):
        if 'outputs' in o:
            o['outputs'] = []   <===== where there is an output replace with empty list

    with open(nb_path, 'w') as f:
        json.dump(notebook, f, indent = 2). <=== write out the modified notebook body to same path