S

18

152

I have some Python code example I'd like to share that should do something different if executed in the terminal Python / IPython or in the IPython notebook.

How can I check from my Python code if it's running in the IPython notebook?

Sorrento answered 14/3, 2013 at 14:25 Comment(1)

I suggest accepting Gustavo Bezerra's answer. The currently accepted answer doesn't answer the question, and Gustavo's answer is the highest-scored answer that still works in the latest version of Jupyter Notebook. – Sugar 21/9, 2019 at 19:37

E

4

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.

Extenuation answered 14/3, 2013 at 14:56 Comment(12)

The link above to the IPython Rich Display System is broken. Here is the link to current documentation: ipython.org/ipython-doc/dev/config/integrating.html, and here is a link to some great examples: nbviewer.ipython.org/github/ipython/ipython/blob/master/… – Fellow 18/4, 2014 at 13:34

I have a problem like this in my drawing module . I need to import call matplotlib.use("Agg") there for travis-ci to allow saving drawings (see #4706951 ) But this generates a warning in the notebook UserWarning: This call to matplotlib.use() has no effect because the backend has already been chosen; How to solve this ? – Candler 19/5, 2014 at 6:21

This mean somethign else have already make a call to matplotlib.use, or you are starting ipython with an option that already set the mlp backend (--matplolib=.. or --pylab, or %matplotlib...) – Extenuation 19/5, 2014 at 9:54

Link in this answer is stale. – Sharpedged 26/2, 2016 at 15:58

I have one example: progress bars. Jupyter notebook terminal emulator does not support extended terminal control characters such as \x1b[A (move up), so it's not possible to print nested bars. No problem with ipywidgets, we can use native Jupyter widgets to display progress bars. But then we have two different means of displaying a progress bar, and an application might want to know what is the display environment in order to adapt and print the compatible bar. – Sannyasi 7/6, 2016 at 20:19

for instance, I want to set IPython config to always run %matplotlib inline when it acts as a notebook, but not in a terminal, since that is not needed. – Susurration 12/12, 2017 at 10:58

While this is a perfectly valid opinion, this answer does not address the actual question. No matter how much you would wish it be otherwise there will always be differences in behavior that may matter. – Oophorectomy 5/3, 2019 at 18:34

Many users may actually only need to know if they are in a kernel, not necessarily in a notebook, which can be done via github.com/ipython/ipython/issues/11694 – Wier 30/4, 2019 at 3:27

In my example, I have a line display(HTML(...)) in my script. When run from a notebook it works. When run as a normal Python script it just prints <IPython.core.display.HTML object> which is useless, so I need to manually open a browser to display the HTML code, or convert the HTML to something that I can print in the terminal. – Budding 2/10, 2019 at 12:57

The intention is good, but the practice is different. There are perfectly valid reasons to make code depend on the environment. My application is the startup file startup.ipy. When in the terminal IPython, for convenience I like to have a few packages pre-imported. When in a notebook, that is considered bad style, and not necessary because I can put the imports in the first cell, not having to type them again and again. – Troxler 30/1, 2020 at 19:7

This does not answer the question asked. The title is "How can I check if code is executed in the IPython notebook?" Please, either change the correct answer or the title of the question. – Lophophore 3/6, 2020 at 17:26

This non-answer answer predates ubiquitous Jupyter use. There are things that are literally impossible in one context and not another, and this is modern Python. E.g., try using display() from the command line. – Sarita 2/9, 2020 at 15:50

C

137

The following worked for my needs:

get_ipython().__class__.__name__

It returns 'TerminalInteractiveShell' on a terminal IPython, 'ZMQInteractiveShell' on Jupyter (notebook AND qtconsole) and fails (NameError) on a regular Python interpreter. The function get_ipython() is available on the global namespace by default when IPython is started.

Wrapping it in a simple function:

def is_notebook() -> bool:
    try:
        shell = get_ipython().__class__.__name__
        if shell == 'ZMQInteractiveShell':
            return True   # Jupyter notebook or qtconsole
        elif shell == 'TerminalInteractiveShell':
            return False  # Terminal running IPython
        else:
            return False  # Other type (?)
    except NameError:
        return False      # Probably standard Python interpreter

The above was tested with Python 3.5.2, IPython 5.1.0 and Jupyter 4.2.1 on macOS 10.12 and Ubuntu 14.04.4 LTS

EDIT: This still works fine in 2022 on newer Python/IPython/Jupyter/OS versions

Chalcocite answered 23/9, 2016 at 13:43 Comment(7)

On jupyter console, unfortunately get_ipython() returns an instance of ZMQInteractiveShell also – Emplace 25/11, 2017 at 0:33

If someone is interested in detecting whether the notebook is running on Google Colab you can check this: get_ipython().__class__.__module__ == "google.colab._shell" – Calctufa 19/11, 2018 at 22:4

This only works for code in the notebook. It doesn't work if the function is in an imported package. – Oophorectomy 5/3, 2019 at 18:45

@ChristopherBarber That's not what I see. If I paste this function into a file test.py then run from test import isnotebook; print(isnotebook()) in a Jupyter Notebook, it prints True. (Tested on Notebook server versions 5.2.1 and 6.0.1.) – Sugar 21/9, 2019 at 19:33

I thought there was some case that did not work for me, but unfortunately I don't remember the details. Perhaps it is no longer a problem or perhaps I was just confused. – Oophorectomy 20/7, 2020 at 21:29

the code of this answer is automatically generated by Github Copilot when you type the function name def we_are_in_jupyter() :) imgur.com/9mx9COw You've made it to the brain of the AI – Eam 16/10, 2022 at 20:21

In my case, I needed to determine whether my code was running within Jupyter Notebook (on VS Code) or within a .py file. I found that just running get_ipython() within a try/except block was sufficient; that function would fail when launched within a Python file but would exit successfully within a Jupyter Notebook. Not sure whether this is also the case on Linux but I can check. – Lathrope 28/10, 2023 at 3:39

H

46

You can check whether python is in interactive mode with the following snippet [1]:

def is_interactive():
    import __main__ as main
    return not hasattr(main, '__file__')

I have found this method very useful because I do a lot of prototyping in the notebook. For testing purposes, I use default parameters. Otherwise, I read the parameters from sys.argv.

from sys import argv

if is_interactive():
    params = [<list of default parameters>]
else:
    params = argv[1:]

Following the implementation of autonotebook, you can tell whether you are in a notebook using the following code.

def in_notebook():
    try:
        from IPython import get_ipython
        if 'IPKernelApp' not in get_ipython().config:  # pragma: no cover
            return False
    except ImportError:
        return False
    except AttributeError:
        return False
    return True

Hyperthermia answered 15/3, 2014 at 14:5 Comment(8)

python -c "def is_interactive(): > import main as main > return not hasattr(main, 'file') > print is_interactive()" True – Quintessa 21/4, 2015 at 12:55

is_interactive() does not distinguish between notebook and console. – Haya 6/10, 2015 at 5:4

Another caveat, issuing a %run from ipython is non-interactive. You could argue it should be, but it is still a gotcha. – Dennisedennison 16/6, 2017 at 17:36

For others prototyping in the notebook, the variant of Till's approach featured here might be useful. – Should 15/2, 2018 at 18:27

The second half of this answer is useful, but the first half (about is_interactive) seems to me to be basically irrelevant to the question. It's also of dubious correctness; as @Quintessa points out, it counts anything run using python -c as being in "interactive" mode even though this isn't true. I don't want to do it myself since it's not my answer, but I think this would be improved by simply deleting the entire first half of the answer. – Sugar 21/9, 2019 at 19:51

Note that get_ipython will returns None when run from an ordinary python shell or a running a script, so this code needs to guard against that case. – Inez 6/3, 2020 at 18:6

Another note, is that in vscode it does not recognize Python Interactive as Interactive. – Salamander 1/8, 2020 at 5:51

After I tried putting this example in PyCharm, I get this warning: Python versions 3.12, 3.11 do not have module __main__. – Needlecraft 9/2 at 9:21

A

41

To check if you're in a notebook, which can be important e.g. when determining what sort of progressbar to use, this worked for me:

def in_ipynb():
    try:
        cfg = get_ipython().config 
        if cfg['IPKernelApp']['parent_appname'] == 'ipython-notebook':
            return True
        else:
            return False
    except NameError:
        return False

Arleenarlen answered 24/7, 2014 at 15:4 Comment(5)

In my IPython-Notebook (IPython version 3.1), cfg['IPKernelApp']['parent_appname'] is a IPython.config.loader.LazyConfigValue, which does not compare to True with "iypthon-notebook" – Counteroffensive 25/5, 2015 at 12:7

@juanjux get_ipython returns an IPython.kernel.zmq.zmqshell.ZMQInteractiveShell instance in ipynb (Jupyter) and an IPython.terminal.interactiveshell.TerminalInteractiveShell in a terminal REPL, in case you need to differentiate between notebooks and terminal/consoles (which affects plotting). – Gambeson 9/10, 2015 at 21:56

^ therefore you can replace the inside of the try block with: return str(type(get_ipython())) == "<class 'ipykernel.zmqshell.ZMQInteractiveShell'>" – Campman 16/9, 2016 at 2:58

Like @Dux, this doesn't work for me; it always returns false, even in a Notebook. Suspect that this answer became obsolete with the introduction of some sort of lazy config loading system. – Sugar 21/9, 2019 at 19:36

Note also that your config may come back as an empty dict, in which case you would need to add KeyError to the except block. It is probably better however to use code based on Gustavo Bezerra's answer. Even though I get an empty config, I get shell='PyDevTerminalInteractiveShell' when inspecting the class name. – Martz 13/8, 2020 at 2:42

P

27

Recently I encountered a bug in Jupyter notebook which needs a workaround, and I wanted to do this without loosing functionality in other shells. I realized that keflavich's solution does not work in this case, because get_ipython() is available only directly from the notebook, and not from imported modules. So I found a way to detect from my module whether it is imported and used from a Jupyter notebook or not:

import sys

def in_notebook():
    """
    Returns ``True`` if the module is running in IPython kernel,
    ``False`` if in IPython shell or other Python shell.
    """
    return 'ipykernel' in sys.modules

# later I found out this:

def ipython_info():
    ip = False
    if 'ipykernel' in sys.modules:
        ip = 'notebook'
    elif 'IPython' in sys.modules:
        ip = 'terminal'
    return ip

Comments are appreciated if this is robust enough.

Similar way it is possible to get some info about the client, and IPython version as well:

import sys

if 'ipykernel' in sys.modules:
    ip = sys.modules['ipykernel']
    ip_version = ip.version_info
    ip_client = ip.write_connection_file.__module__.split('.')[0]

# and this might be useful too:

ip_version = IPython.utils.sysinfo.get_sys_info()['ipython_version']

Pedrick answered 6/6, 2016 at 15:56 Comment(4)

Hm, I am using the Fedora 23 Jupyter, and there 'Ipython' in sys.modules evaluates to False. Perhaps you mean 'IPython' in sys.modules? This is True in my Jupyter environment. The sys.modules dictionary also doesn't include the 'ipykernel' key - when running inside a notebook. – Gram 30/10, 2016 at 13:17

This is the best answer so far, IMO. Short and sweet. – Lebbie 31/3, 2020 at 19:40

@Lebbie so which of the sub-answers is the best answer? – Boeotia 2/8, 2021 at 11:28

Some packages incorrectly detect running in Jupyter, and then import ipykernel, which results in this logic returning a false positive (e.g. Weights and Biases package). So it will work most of the time, but not always. – Bathhouse 4/1, 2023 at 0:33

Q

13

Tested for python 3.7.3

CPython implementations have the name __builtins__ available as part of their globals which btw. can be retrieved by the function globals().
If a script is running in an Ipython environment then __IPYTHON__ should be an attribute of __builtins__.
The code below therefore returns True if run under Ipython or else it gives False

hasattr(__builtins__,'__IPYTHON__')

Quizmaster answered 25/9, 2019 at 16:12 Comment(9)

Nice and simple! – Chemosynthesis 16/2, 2021 at 11:10

You should probably import builtins though and check hasattr(builtins, "__IPYTHON__"), since __builtins__ is an implementation detail that could change. – Chemosynthesis 16/2, 2021 at 18:16

Downvoted — this is also true in an IPython session – Candiecandied 25/4, 2021 at 22:21

NameError: name '__IPYTHON__' is not defined – Boeotia 2/8, 2021 at 11:30

@Boeotia You probably missed the quotes around the string. – Jacquiline 7/9, 2021 at 7:41

Been using this in all my PyPI packages since 2019 and so far, no one has complained. It is notoriously hard to test with pytest but I will continue using it until one of the other tricks is proven best. Seems like a great article for someone to summarize and test against all the versions of environments for the community! – Idou 8/10, 2021 at 16:34

This works perfectly!!, and does not need the inconvinient and slow try except clauses – Leavings 4/10, 2022 at 14:12

This is a fine test for running in IPython, but not for running in a notebook. E.g. it returns true in PyCharm Python Console when using IPython. – Bathhouse 3/1, 2023 at 23:48

On Python 3.11/IPython 8.13 I found I had to use import builtins and hasattr(builtins, "__IPYTHON__") for this to work; __builtins__ returned False for IPython too. – Cuthbert 30/5, 2023 at 8:11