How to (intermittently) skip certain cells when running IPython notebook?

Though this isn’t exactly what you seem to be looking for, if you wish to entirely omit the execution of a cell (where no cached results are loaded), you can add the following hack at the beginning of a cell (assuming you are using a Unix-based OS):

%%script false

or a variant (working as of early 2020 — see here for explanation):

%%script false --no-raise-error

If no cached results are expected to be loaded, I find the Freeze nbextension quite useful to this end.

Although unofficial, I strongly recommend to give these notebook extensions a try if you have never used them before.

To install the extension machinery,

$ pip install jupyter_contrib_nbextensions && jupyter contrib nbextension install

To enable the Freeze extension, launch jupyter notebook and open a new notebook, from the menu select Edit > nbextensions config, and then check Freeze.

The %%script false solution stopped working some time in 2019.

Here are some other available workarounds. These are based on programs ignoring their arguments when you tell them not to expect any. Here are some easy examples:

Perl:

%%perl -e0
​
for i in range(10): print(i)

Here you’re running: perl -e '0' cellcontents

A more memorable version:

%%perl -eat
​
for i in range(10): print(i)

Here you’re running: perl -e 'at' cellcontents

Bash:

%%bash -c :

for i in range(10): print(i)

: is a no-op in bash, so you’re running: bash -c : cellcontents

I haven’t looked at the external magic implementation code, but I’m pretty sure "cellcontents" are passed as arguments and won’t be interpreted by shell by mistake, say if you were to include ; in them and accidentally inject some bad code. But I can’t guarantee you that.

I’m sure you can come up with other creative solutions, by looking at the supported programs here: https://ipython.readthedocs.io/en/stable/interactive/magics.html#cell-magics

Here’s a simple and universal solution without the need for workarounds:
Simply type this as the top line of the cell to skip the cell:

%%script echo skipping

It’s tested on Windows and Mac with recent Jupyter, and I think it should work on other Unix-like platforms as well because they also have an echo command. Some of the other proposed solutions are more platform-specific.

Of course you can put what ever text you like instead of "skipping". When you execute the cell, it will merely print this text instead of executing the code in the cell.

This question is a bit older, but the most convenient answer seems to be missing. You can use the ‘initialization cells’ from the NBextensions. Once installed/activated, you can in any notebook mark cells as ‘initialization cells’ which can then be run with a specific button.

• Install NBextensions:here

• Activate ‘initialization cells’ when you launch the jupyter dashboard

• In your notebook, in the ‘view’ menu choose ‘cell toolbar’ then ‘initialization cell’

• Next to each cell there is now a checkbox. Mark all the cells you want to run for initialization
• When reopening a notebook, click the button that looks like a pocket calculator to run all the initialization cells.

The simplest way to skip python code in jupyter notebook cell from running, I temporarily convert those cells to markdown.

For the cells you wish to skip when you press Run All you can use try/except blocks, where you try to display the already calculated information in the try block, and perform the calculation in the except block.

Take this cell for example:

my_results = 2 # Assume this is a bigger calculation
print(my_results)
print('displayed my results.')

To skip the calculation for this cell in subsequent runs, change the contents of this cell to the following:

try:
  print(my_results)
  print('displayed state value')
except:
  my_results = 2 # Assume this is a bigger calculation
  print(my_results)
  print('displayed newly calculated value')

The first time you run this cell, it will attempt to print the value of the state variable my_results. This throws an exception so it jumps to the except block and does the actual calculation of my_results (which in this case just makes it equate to 2). At the end of the first run the output for this cell would be:

2
displayed newly calculated value

When you run the cell a second time (whether that be manually or via Run All), the try block will first execute but this time since the variable is available in the state, it does not throw an exception. Instead it displays the result and the except block is never run. At the end of the second run the output of this cell would be:

2
displayed state value

This doesn’t meet your explicit criteria that the cell should be completely skipped, but effectively the calculation is skipped.

If the displaying of the information is more complex than using a single print or display, it would probably be cleaner if you make the displaying routine into a function like so:

def print_my_results(my_result):
  print(my_result)
  print('displayed my result.')

try:
  print_my_results(my_results)
except:
  my_results = 2 # Assume this is a bigger calculation
  print_my_results(my_results)