How to Check If Code Is Executed in the Ipython Notebook

How can I check if code is executed in the IPython notebook?

The question is what do you want execute differently.

We do our best in IPython prevent the kernel from knowing to which kind of frontend is connected, and actually you can even have a kernel connected to many differents frontends at the same time. Even if you can take a peek at the type of stderr/out to know wether you are in a ZMQ kernel or not, it does not guaranties you of what you have on the other side. You could even have no frontends at all.

You should probably write your code in a frontend independent manner, but if you want to display different things, you can use the rich display system (link pinned to version 4.x of IPython) to display different things depending on the frontend, but the frontend will choose, not the library.

Check if module is running in Jupyter or not

You could use the following snippet to figure out if you are in jupyter, ipython or in a terminal:

def type_of_script():
    try:
        ipy_str = str(type(get_ipython()))
        if 'zmqshell' in ipy_str:
            return 'jupyter'
        if 'terminal' in ipy_str:
            return 'ipython'
    except:
        return 'terminal'

You can find more indepth info at How can I check if code is executed in the IPython notebook?

How to check if you are in a Jupyter notebook

You don't need to check if the code is being run from a Notebook; display() prints text when called from the command line.

test.py:

from IPython.display import display
import pandas as pd 

my_df = pd.DataFrame({'foo':[1,2,3],'bar':[7,8,9]})
display(my_df)

From the command line:

$ python test.py 
   bar  foo
0    7    1
1    8    2
2    9    3

From a Jupyter Notebook:

UPDATE
To check whether you're running inside an interactive Ipython shell (command-line or browser-based), check for get_ipython. (Adapted from the Ipython docs)

Modified test.py:

from IPython.display import display, HTML
import pandas as pd 
my_df = pd.DataFrame({'foo':[1,2,3],'bar':[7,8,9]})

try:
    get_ipython
    display(my_df)
except:
    print(my_df)

This approach will:

- pretty-print in a browser Jupyter notebook

- print text when run as a script from the command line (e.g. python test.py)

- if run line-by-line in a Python shell, it will not turn into an interactive Ipython shell after printing

Determine if we're in an IPython notebook session

You can't detect that the frontend is a notebook with perfect precision, because an IPython Kernel can have one or more different Jupyter frontends with different capabilities (terminal console, qtconsole, notebook, etc.). You can, however, identify that it is a Kernel and not plain terminal IPython:

import sys

def is_kernel():
    if 'IPython' not in sys.modules:
        # IPython hasn't been imported, definitely not
        return False
    from IPython import get_ipython
    # check for `kernel` attribute on the IPython instance
    return getattr(get_ipython(), 'kernel', None) is not None

Since the notebook is so much more popular than other frontends, this indicates that the frontend is probably a notebook, but not conclusively. So you want to be sure there's a way out for the more primitive frontends.

How to tell whether a function is being called from a jupyter notebook or not?

There doesn't seemed be a correct or future-proof way to pull this off but I would use this pattern:

import os

if "JPY_PARENT_PID" in os.environ:
    print('Hello, jupyter')
else:
    print('Hello, Spyder')

It's a little bit more specific and has less side-effects than the answer given here. It works in jupyter notebook as well as jupyter lab so I think it is safe to assume that it will future-proofish for a while.

Let me know how it works for you.

UPDATE:

The solution above only works in spyder >3.2

However the solution below should work for all versions of jupyter notebook or spyder, maybe. Basic it's the same if else loop from above but we just test the os.environ for the presence of spyder stuff.

import os

# spyder_env: was derived in spyder 3.2.8 ipython console running:
# [i for i in os.environ if i[:3] == "SPY"]

spyder_env = set(['SPYDER_ARGS',
                  'SPY_EXTERNAL_INTERPRETER',
                  'SPY_UMR_ENABLED',
                  'SPY_UMR_VERBOSE',
                  'SPY_UMR_NAMELIST',
                  'SPY_RUN_LINES_O',
                  'SPY_PYLAB_O',
                  'SPY_BACKEND_O',
                  'SPY_AUTOLOAD_PYLAB_O',
                  'SPY_FORMAT_O',
                  'SPY_RESOLUTION_O',
                  'SPY_WIDTH_O',
                  'SPY_HEIGHT_O',
                  'SPY_USE_FILE_O',
                  'SPY_RUN_FILE_O',
                  'SPY_AUTOCALL_O',
                  'SPY_GREEDY_O',
                  'SPY_SYMPY_O',
                  'SPY_RUN_CYTHON',
                  'SPYDER_PARENT_DIR'])

# Customize to account for spyder plugins running in jupyter notebook/lab.
n = 0

if "JPY_PARENT_PID" in os.environ:
    # Compare the current os.environ.keys() to the known spyder os.environ.
    overlap = spyder_env & set(os.environ.keys())

    if len(overlap) == n:
        print('Hello, jupyter')   

    # This could be a more specific elif statment if needed.
    else:
        print('Hello, Spyder')

Does that solve the problem for you?

How can I programmatically check that I am running code in a notebook in julia?

What about @__FILE__ this yields REPL[_] in Julia REPL, In[_] in Jupyter and "/path/to/file.jl#==#hashocde" in Pluto so the test could be:

match(r"^In\[[0-9]*\]$", @__FILE__) != nothing

and in VSCode:

so you can check if the file ends with ".ipynb" if you want to find VSCode. Moreover: isdefined(Main, :VSCodeServer) yields true if you run from VSCode.

Python tqdm import check if jupyter notebook or lab is running

# either:
from tqdm.autonotebook import tqdm
# or to suppress the warning:
from tqdm.auto import tqdm

For other modules/checks, see How can I check if code is executed in the IPython notebook? (But note that the accepted albeit unpopular answer there is "this is intentionally not meant to be possible by design.")

---

Related Topics