__file__ does not exist in Jupyter Notebook

If you want to get path of the directory in which your script is running, I would highly recommend using,

os.path.abspath('')

Advantages

• It works from Jupyter Notebook
• It work from REPL
• It doesn't require Python 3.4's pathlib

Please note that one scenario where __file__ has advantage is when you are invoking python from directory A but running script in directory B. In that case above as well as most other methods will return A, not B. However for Jupyter notbook, you always get folder for .ipyn file instead of the directory from where you launched jupyter notebook.

In modern Python (v3.4+) we can use pathlib to get the notebook's directory:

from pathlib import Path

cwd = Path().resolve()
# cwd == PosixPath('/path/to/this/jupyter/ipynb/file's/directory/')

# or this way, thanks @NunoAndré:
cwd = Path.cwd()
# cwd == PosixPath('/path/to/this/jupyter/ipynb/file's/directory/')

Update

@ShitalShah I cannot reproduce the error you are reporting. Jupyter notebook seems to work fine, regardless of the current working directory the application was started.

Example: file ~/dir1/dir2/untitled.ipynb and Jupyter notebook started in ~/dir1:

Jupyter notebook started in ~/dir1/dir2:

It's not possible to get the path to the notebook. You may find a way to get it that only works in one environment (eg os.getcwd()), but it won't necessarily work if the notebook is loaded in a different way.

Instead, try to write the notebook so that it doesn't need to know its own path. If doing something like getting the pwd, then be sure to fail fast / print an error if this doesn't work, vs. just silently trying to continue on.

See also: https://github.com/ipython/ipython/issues/10123

I'm new to python, but this works for me.

You can get os.path.dirname(__file__) equivalence by:

sys.path[0]

As mentioned in this post, we can use get_ipython to check if the script is executed from a Jupyter Notebook (.ipynb file) and then assume if not it is executed from a .py file instead. I found as mentioned here that we can use extract_module_locals to get the name of the current Jupyter Notebook running.

This works for me:

import os

try:
    from IPython import get_ipython, extract_module_locals        
    get_ipython

    print("Running from .ipynb file")        

    this_dir, this_filename = os.path.split("/".join(
        extract_module_locals()[1]["__vsc_ipynb_file__"].split("/")[-5:]
    ) )
    print(f'this_dir:\t {this_dir}')
    print(f'this_filename:\t {this_filename}')
    
except:
    print("Running from .py file")
    this_dir, this_filename = os.path.split(os.path.abspath(__file__) )
    print(f'this_dir:\t {this_dir}')
    print(f'this_filename:\t {this_filename}')

# Navigate to file located in one folder up:
os.path.abspath(os.path.join(os.path.dirname(this_dir), 'MyFile.xlsx'))

You can may get it by

import inspect
from pathlib import Path

module_path = Path(inspect.getframeinfo(inspect.currentframe()).filename).resolve()

It will not return currrent working directory, but path to module, even if module is imported from elsewhere.

As stated in comments, it may not work if you use it vie external tool like VS Code.

[EDITED]: I stated, that __file__ is available in new Jupyter. It's been my fault as t worked for me because of some tool I used over Jupyter (I do not remeber what tool...).

For Jupyter Notebooks, enclose the file with quotes i.e "file". Then use the dirname method to get the file DIR

import os

THIS_DIR = os.path.dirname(os.path.abspath("__file__"))
print(THIS_DIR)

# /home/brightkoech/Projects/EPL-Streamlit-Visualisation/src

Building on the answer from https://stackoverflow.com/a/79058785/9905602, I wrote this helper function you can import in a notebook.

The cool thing about this solution is that you can put this function in any other file (e.g. notebook_utils.py) from which you can import the function and run it in your notebook.

import sys
from pathlib import Path
from types import FrameType

def find_notebook_file() -> Path | None:
    """Returns the path to the current notebook file, if available."""
    f: FrameType | None = sys._getframe()
    while f:
        if "__vsc_ipynb_file__" in f.f_locals:
            return Path(f.f_locals["__vsc_ipynb_file__"])
        f = f.f_back
    raise RuntimeError("Could not find '__vsc_ipynb_file__'. Are you running in a VSCode Jupyter notebook?")

The answer I referenced was using extract_module_locals which calls sys._getframe(1). This works if you define the function in your notebook but breaks if it is defined in another file and imported in the notebook because then the call to extract_module_locals still accesses the calling frame but then the caller is not the notebook cell directly, but rather the function inside the module. That causes that now you are one or more frames away from where __vsc_ipynb_file__ is. The depth argument of sys._getframe doesn't account for this, but my solution solves this by searching up the stack frame dynamically.

This way, my solution works both when defined inline in the notebook or when defined elsewhere and imported in the notebook.