233

Is there a universal approach in Python, to find out the path to the file that is currently executing?

Failing approaches

path = os.path.abspath(os.path.dirname(sys.argv[0]))

This does not work if you are running from another Python script in another directory, for example by using execfile in 2.x.

path = os.path.abspath(os.path.dirname(__file__))

I found that this doesn't work in the following cases:

  • py2exe doesn't have a __file__ attribute, although there is a workaround
  • When the code is run from IDLE using execute(), in which case there is no __file__ attribute
  • On Mac OS X v10.6 (Snow Leopard), I get NameError: global name '__file__' is not defined

Test case

Directory tree

C:.
|   a.py
\---subdir
        b.py

Content of a.py

#! /usr/bin/env python
import os, sys

print "a.py: sys.argv[0]=", sys.argv[0]
print "a.py: __file__=", __file__
print "a.py: os.getcwd()=", os.getcwd()
print

execfile("subdir/b.py")

Content of subdir/b.py

#! /usr/bin/env python
import os, sys

print "b.py: sys.argv[0]=", sys.argv[0]
print "b.py: __file__=", __file__
print "b.py: os.getcwd()=", os.getcwd()
print

Output of python a.py (on Windows)

a.py: __file__= a.py
a.py: os.getcwd()= C:\zzz

b.py: sys.argv[0]= a.py
b.py: __file__= a.py
b.py: os.getcwd()= C:\zzz

Related (but these answers are incomplete)

Karl Knechtel
  • 62,466
  • 11
  • 102
  • 153
sorin
  • 161,544
  • 178
  • 535
  • 806
  • `execfile` doesn't exist any more, and it's not clear to me why the code in the test case **should** return anything different, or what **problem one might hope to solve** by having `b.py` able to identify its own source code location. For that matter, **code can run from non-file sources**. – Karl Knechtel Jan 10 '23 at 01:09

13 Answers13

100

First, you need to import from inspect and os

from inspect import getsourcefile
from os.path import abspath

Next, wherever you want to find the source file from you just use

abspath(getsourcefile(lambda:0))
ArtOfWarfare
  • 20,617
  • 19
  • 137
  • 193
  • 1
    Best answer. Thank you. – Devan Williams Aug 04 '15 at 19:02
  • 4
    Great answer. Thanks. It also seems to also be the shortest and most portable (running on different os-es) answer and doesn't encounter problems such as `NameError: global name '__file__' is not defined` (another solution caused this). – Edward Nov 04 '15 at 19:35
  • Another possibility which is equally short: `lambda:_`. It worked for me - not sure it'll always work. `lambda:0` probably runs faster by some immeasurably small amount (or maybe not so small... might be a load immediate or something even faster for `0` vs a load global for `_`?) Debatable whether it's cleaner or easier to read or even more clever/obscure. – ArtOfWarfare Dec 22 '17 at 22:19
  • 2
    As with almost every proposal I have tried, this just returns the cwd for me, not the directory file I am running (debugging). – James Sep 23 '18 at 00:44
  • 2
    @James - This code goes in the file you're running... running `getsourcefile(lambda:0)` will be meaningless and just return `None` if you try running it at an interactive prompt (since the `lambda` won't be in any source file.) If you want to know where another function or object is coming from in an interactive environment, maybe `abspath(getsourcefile(thatFunctionOrObject))` will be more helpful for you? – ArtOfWarfare Sep 23 '18 at 03:08
  • So it doesn't work when stepping through file code @artofwarfare? – James Sep 24 '18 at 04:15
  • What does `lambda:0` do, and why is it being done? – Brōtsyorfuzthrāx Oct 06 '22 at 08:59
  • 2
    @Brōtsyorfuzthrāx - It creates a function because `getsourcefile` wants a function. `getsourcefile` then returns the file which contains the function it's given, which would be whatever file we typed that line in. The function just returns `0` if it were ever run, which it never will be. – ArtOfWarfare Oct 06 '22 at 19:25
89

You can't directly determine the location of the main script being executed. After all, sometimes the script didn't come from a file at all. For example, it could come from the interactive interpreter or dynamically generated code stored only in memory.

However, you can reliably determine the location of a module, since modules are always loaded from a file. If you create a module with the following code and put it in the same directory as your main script, then the main script can import the module and use that to locate itself.

some_path/module_locator.py:

def we_are_frozen():
    # All of the modules are built-in to the interpreter, e.g., by py2exe
    return hasattr(sys, "frozen")

def module_path():
    encoding = sys.getfilesystemencoding()
    if we_are_frozen():
        return os.path.dirname(unicode(sys.executable, encoding))
    return os.path.dirname(unicode(__file__, encoding))

some_path/main.py:

import module_locator
my_path = module_locator.module_path()

If you have several main scripts in different directories, you may need more than one copy of module_locator.

Of course, if your main script is loaded by some other tool that doesn't let you import modules that are co-located with your script, then you're out of luck. In cases like that, the information you're after simply doesn't exist anywhere in your program. Your best bet would be to file a bug with the authors of the tool.

Daniel Stutzbach
  • 74,198
  • 17
  • 88
  • 77
  • 2
    I mention that on OS 10.6 I get `NameError: global name '__file__' is not defined` using __file__ and this is not inside the IDLE. Think that `__file__` is defined only inside modules. – sorin Apr 13 '10 at 18:59
  • 1
    @Sorin Sbarnea: I updated my answer with how I get around that. – Daniel Stutzbach Apr 13 '10 at 19:37
  • 2
    Thanks, but in fact the problem with missing `__file__` had nothing to do with Unicode. I don't know why `__file__` is not defined but I'm looking for a generic solution this will work an all cases. – sorin Apr 13 '10 at 21:29
  • @Sorin Sbarnea, unicode isn't the part that I added. The key, I believe, is to put the __file__ in a module, not in the main file. In other words, you should be calling `my_module.module_path()`. – Daniel Stutzbach Apr 13 '10 at 23:25
  • 2
    Sorry this is not possible in all cases. For example I try to do this in waf.googlecode.com from inside a wscript file (python). These files are executed but they are not modules and you cannot made them modules (they can be any any subdirectory from the source tree). – sorin Apr 16 '10 at 10:01
  • "For example, it could come from the interactive interpreter or dynamically generated code stored only in memory." Seems like it would still be able to return *something* in those cases. – endolith Mar 18 '12 at 23:45
  • 1
    Won't that give you the location of `some_path/module_locator.py` instead? – Casebash Mar 18 '13 at 06:02
  • 1
    @Casebash: Yes, you're right. Although the answer stipulates to "create a module with the following code and put it in the same directory as your main script", at best it can tell you what directory the executing file is in, but not its actual name. – martineau Apr 24 '13 at 14:30
  • Just one remark: Modules do not always come from files. One can define custom import hooks. Some nice examples can be found here: http://pymotw.com/2/sys/imports.html – Thorsten Kranz Oct 01 '13 at 08:49
  • @sorin use quotes: "__file__" instead of __file__ in the brackets, treat it like a string – lsheng Apr 16 '14 at 08:29
  • This also works on windows when calling a frozen exe/script having setup the path to it. Cheers! – Valmond May 01 '20 at 13:17
  • 1
    This does not work on python 3. unicode was changed to str. I tried adding `if sys.version_info[0] >= 3: unicode = str` ala https://stackoverflow.com/a/53286631/7238575 but it is still giving an error. What should I do to make this work? – Kvothe Feb 08 '21 at 19:47
  • The make this work in python3 one should replace `unicode(, encoding)` with `str()`. – Kvothe Feb 08 '21 at 20:02
  • @Kvothe, I get `decoding str is not supported` when using `str` instead of `unicode` – Valentin_Ștefan Dec 13 '22 at 16:54
30

This solution is robust even in executables:

import inspect, os.path

filename = inspect.getframeinfo(inspect.currentframe()).filename
path     = os.path.dirname(os.path.abspath(filename))
Peter Mortensen
  • 30,738
  • 21
  • 105
  • 131
José Crespo Barrios
  • 823
  • 13
  • 16
16

I was running into a similar problem, and I think this might solve the problem:

def module_path(local_function):
   ''' returns the module path without the use of __file__.  Requires a function defined
   locally in the module.
   from http://stackoverflow.com/questions/729583/getting-file-path-of-imported-module'''
   return os.path.abspath(inspect.getsourcefile(local_function))

It works for regular scripts and in IDLE. All I can say is try it out for others!

My typical usage:

from toolbox import module_path
def main():
   pass # Do stuff

global __modpath__
__modpath__ = module_path(main)

Now I use _modpath_ instead of _file_.

Peter Mortensen
  • 30,738
  • 21
  • 105
  • 131
Garrett Berg
  • 2,585
  • 1
  • 22
  • 21
  • 4
    According to the [PEP8](http://www.python.org/dev/peps/pep-0008/#descriptive-naming-styles) coding style guide, one should never create names with double leading and trailing underscores -- so `__modpath__` should be renamed. You also probably don't need the `global` statement. Otherwise +1! – martineau Jun 30 '12 at 19:13
  • 6
    Actually you can define the local function right in the call to `module_path()`. i.e. `module_path(lambda _: None)` which doesn't depend on the other contents of the script it is in. – martineau Apr 25 '13 at 16:15
  • @martineau: I took your suggestion of `lambda _: None` and have used it for nearly the past two years, but just now I discovered I could condense it down to just `lambda:0`. Is there any particular reason you suggested the form you did, with an ignored argument of `_`, instead of with no argument at all? Is there something superior about `None` prefixed with a space rather than just `0`? They're both equally cryptic, I think, just one is 8 characters long while the other is 14 characters long. – ArtOfWarfare Mar 26 '15 at 17:46
  • @ArtOfWarfare: The difference between the two is that `lambda _:` is a function that takes one argument and `lambda:` is one that doesn't take any. It doesn't matter since the function is never called. Likewise it doesn't matter what return value is used. I guess I chose `None` because at the time it seemed to indicate it was a do-nothing, never-to-be-called function better. The space in front of it is optional and again there only for improved readability (always trying to follow PEP8 is habit-forming). – martineau Mar 26 '15 at 18:06
  • @martineau: It's obviously an abuse of `lambda` though, using it for something it was never meant to do. If you were to follow PEP8, I think the right content for it would be `pass`, not `None`, but it's not valid to put a statement in a `lambda`, so you have to put in something with a value. There's a few valid 2 character things you could put in, but I think the only valid single character things you can put in are 0-9 (or a single character variable name assigned outside the `lambda`.) I figure `0` best indicates the nothingness of 0-9. – ArtOfWarfare Mar 26 '15 at 18:40
  • @ArtOfWarfare: It not an abuse of `lambda`, whose purpose is simply to define an anonymous function. As you point out, using `pass` isn't an option with one, so any valid return value is suitable. Your goal seems to be to write the shortest definition possible, which when we're talking about a few characters, doesn't seem very important to me. BTW, your answer from 2.5 years after this one is essentially simply applying my original comment to this one. – martineau Mar 26 '15 at 18:47
  • I found almost the same solution independently and have created a simpler answer below with more information (https://stackoverflow.com/a/33531619/3787376). – Edward Aug 24 '17 at 19:58
12

You have simply called:

path = os.path.abspath(os.path.dirname(sys.argv[0]))

instead of:

path = os.path.dirname(os.path.abspath(sys.argv[0]))

abspath() gives you the absolute path of sys.argv[0] (the filename your code is in) and dirname() returns the directory path without the filename.

dgb
  • 133
  • 1
  • 4
  • thks! Only your answer can manage to make path a global variable in a separate module. I can now always call path_util.cwd_path from anywhere to get the directory of the caller py. – CodingNinja Sep 23 '22 at 12:55
7

The short answer is that there is no guaranteed way to get the information you want, however there are heuristics that work almost always in practice. You might look at How do I find the location of the executable in C?. It discusses the problem from a C point of view, but the proposed solutions are easily transcribed into Python.

Community
  • 1
  • 1
Dale Hagglund
  • 16,074
  • 4
  • 30
  • 37
  • Hello, my flag was declined so I've now started a discussion on meta: http://meta.stackoverflow.com/questions/277272/not-an-answer-flag-declined?noredirect=1#comment119282_277272 – ArtOfWarfare Nov 19 '14 at 15:08
  • There are simple working answers already on this page however. My solution works well: https://stackoverflow.com/a/33531619/3787376. – Edward Aug 25 '17 at 04:02
6

See my answer to the question Importing modules from parent folder for related information, including why my answer doesn't use the unreliable __file__ variable. This simple solution should be cross-compatible with different operating systems as the modules os and inspect come as part of Python.

First, you need to import parts of the inspect and os modules.

from inspect import getsourcefile
from os.path import abspath

Next, use the following line anywhere else it's needed in your Python code:

abspath(getsourcefile(lambda:0))

How it works:

From the built-in module os (description below), the abspath tool is imported.

OS routines for Mac, NT, or Posix depending on what system we're on.

Then getsourcefile (description below) is imported from the built-in module inspect.

Get useful information from live Python objects.

  • abspath(path) returns the absolute/full version of a file path
  • getsourcefile(lambda:0) somehow gets the internal source file of the lambda function object, so returns '<pyshell#nn>' in the Python shell or returns the file path of the Python code currently being executed.

Using abspath on the result of getsourcefile(lambda:0) should make sure that the file path generated is the full file path of the Python file.
This explained solution was originally based on code from the answer at How do I get the path of the current executed file in Python?.

Edward
  • 1,062
  • 1
  • 17
  • 39
  • yeah I just came up with the same solution... way better than the answers that just say it can't reliably be done... unless the question isn't asking what I think it is... – Grady Player Nov 17 '16 at 22:45
  • Again this works from Python on a command line, but not in the iPython interpreter. It gives: Current Path: C:\Users\PowerUser\Desktop\) – Rich Lysakowski PhD Nov 12 '22 at 05:19
5

This should do the trick in a cross-platform way (so long as you're not using the interpreter or something):

import os, sys
non_symbolic=os.path.realpath(sys.argv[0])
program_filepath=os.path.join(sys.path[0], os.path.basename(non_symbolic))

sys.path[0] is the directory that your calling script is in (the first place it looks for modules to be used by that script). We can take the name of the file itself off the end of sys.argv[0] (which is what I did with os.path.basename). os.path.join just sticks them together in a cross-platform way. os.path.realpath just makes sure if we get any symbolic links with different names than the script itself that we still get the real name of the script.

I don't have a Mac; so, I haven't tested this on one. Please let me know if it works, as it seems it should. I tested this in Linux (Xubuntu) with Python 3.4. Note that many solutions for this problem don't work on Macs (since I've heard that __file__ is not present on Macs).

Note that if your script is a symbolic link, it will give you the path of the file it links to (and not the path of the symbolic link).

Peter Mortensen
  • 30,738
  • 21
  • 105
  • 131
Brōtsyorfuzthrāx
  • 4,387
  • 4
  • 34
  • 56
4

You can use Path from the pathlib module:

from pathlib import Path

# ...

Path(__file__)

You can use call to parent to go further in the path:

Path(__file__).parent
Gavriel Cohen
  • 4,355
  • 34
  • 39
  • 3
    This answer uses the `__file__` variable which can be **unreliable** (isn't always the full file path, doesn't work on every operating system etc.) as StackOverflow users have often mentioned. Changing the answer to not include it will cause less problems and be more cross-compatible. For more information, see https://stackoverflow.com/a/33532002/3787376. – Edward Aug 30 '17 at 14:36
  • @mrroot5 Ok, so delete your comment please. – Gavriel Cohen Aug 14 '18 at 09:14
1

Simply add the following:

from sys import *
path_to_current_file = sys.argv[0]
print(path_to_current_file)

Or:

from sys import *
print(sys.argv[0])
Papershine
  • 4,995
  • 2
  • 24
  • 48
H. Kamran
  • 366
  • 2
  • 12
1

If the code is coming from a file, you can get its full name

sys._getframe().f_code.co_filename

You can also retrieve the function name as f_code.co_name

Alex Cohn
  • 56,089
  • 9
  • 113
  • 307
1

The main idea is, somebody will run your python code, but you need to get the folder nearest the python file.

My solution is:

import os
print(os.path.dirname(os.path.abspath(__file__)))

With os.path.dirname(os.path.abspath(__file__)) You can use it with to save photos, output files, ...etc

ThienSuBS
  • 1,574
  • 18
  • 26
  • An explanation would be in order. E.g., what is the idea/gist? Please respond by [editing (changing) your answer](https://stackoverflow.com/posts/55442345/edit), not here in comments (***without*** "Edit:", "Update:", or similar - the answer should appear as if it was written today). – Peter Mortensen Sep 06 '21 at 19:16
-2
import os
current_file_path=os.path.dirname(os.path.realpath('__file__'))
Mohamed.Abdo
  • 2,054
  • 1
  • 19
  • 12
  • 1
    This does not make sense. First, `'__file__'` should not be a string, second, if you did `__file__`, this would only work for the file that this line of code is in, and not the file that is executed? – Andreas Storvik Strauman May 02 '19 at 12:41
  • An explanation would be in order. E.g., what is the idea/gist? Please respond by [editing (changing) your answer](https://stackoverflow.com/posts/55522708/edit), not here in comments (***without*** "Edit:", "Update:", or similar - the answer should appear as if it was written today). – Peter Mortensen Sep 06 '21 at 19:16