Comment obtenir le chemin du fichier actuellement exécuté en Python ?

Question

Y a-t-il une approche universelle en Python pour trouver le chemin du fichier actuellement en cours d'exécution?

Approches infructueuses

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

Cela ne fonctionne pas si vous exécutez à partir d'un autre script Python dans un autre répertoire, par exemple en utilisant execfile en 2.x.

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

J'ai constaté que cela ne fonctionne pas dans les cas suivants:

• py2exe n'a pas d'attribut __file__, même s'il existe une solution de contournement
• Lorsque le code est exécuté depuis IDLE en utilisant execute(), auquel cas il n'y a pas d'attribut __file__
• Sous Mac OS X v10.6 (Snow Leopard), j'obtiens NameError: global name '__file__' is not defined

Cas de test

Arborescence du répertoire

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

Contenu de 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")

Contenu de 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

Sortie de python a.py (sur 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

Lié (mais ces réponses ne sont pas complètes)

• Trouver le chemin du fichier en cours d'exécution
• Le chemin du fichier actuel dépend de la façon dont je lance le programme
• Comment puis-je connaître le chemin du script en cours d'exécution en Python?
• Changer de répertoire vers le répertoire d'un script Python

Answer 1

Vous ne pouvez pas déterminer directement l'emplacement du script principal en cours d'exécution. Après tout, parfois le script ne vient pas du tout d'un fichier. Par exemple, il pourrait provenir de l'interpréteur interactif ou du code généré dynamiquement stocké uniquement en mémoire.

Cependant, vous pouvez déterminer de manière fiable l'emplacement d'un module, car les modules sont toujours chargés à partir d'un fichier. Si vous créez un module avec le code suivant et le placez dans le même répertoire que votre script principal, alors le script principal peut importer le module et l'utiliser pour se localiser.

some_path/module_locator.py:

def we_are_frozen():
    # Tous les modules sont intégrés à l'interpréteur, par exemple, par 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()

Si vous avez plusieurs scripts principaux dans différents répertoires, vous pourriez avoir besoin de plus d'une copie de module_locator.

Bien sûr, si votre script principal est chargé par un autre outil qui ne vous permet pas d'importer des modules situés au même endroit que votre script, alors vous êtes malchanceux. Dans des cas comme celui-ci, les informations que vous recherchez tout simplement n'existent nulle part dans votre programme. Votre meilleure option serait de signaler un bogue aux auteurs de l'outil.

Answer 2

Tout d'abord, vous devez importer de inspect et os

from inspect import getsourcefile
from os.path import abspath

Ensuite, à l'endroit où vous voulez trouver le fichier source, vous utilisez simplement

abspath(getsourcefile(lambda:0))

Answer 3

J'avais rencontré un problème similaire, et je pense que cela pourrait résoudre le problème :

def module_path(local_function):
   ''' retourne le chemin du module sans utiliser __file__.  Nécessite une fonction définie
   localement dans le module.
   depuis http://stackoverflow.com/questions/729583/getting-file-path-of-imported-module'''
   return os.path.abspath(inspect.getsourcefile(local_function))

Cela fonctionne pour les scripts réguliers et dans IDLE. Tout ce que je peux dire, c'est d'essayer pour les autres !

Mon utilisation typique :

from toolbox import module_path
def main():
   pass # Faire des choses

global __modpath__
__modpath__ = module_path(main)

Maintenant j'utilise __modpath__ au lieu de __file__.

Answer 4

La réponse courte est qu'il n'y a pas de moyen garanti d'obtenir l'information que vous voulez, cependant il existe des heuristiques qui fonctionnent presque toujours en pratique. Vous pouvez consulter Comment trouver l'emplacement de l'exécutable en C?. Il aborde le problème d'un point de vue C, mais les solutions proposées peuvent facilement être transcrites en Python.

Answer 5

import os

# Ma solution pour les fichiers sur disque:
# dans a.py ou n'importe quel module

class SomeFoo(object):

    def where(self):
        rsp = os.path.dirname(__file__)
        print(rsp)

# a.py

bla = SomeFoo()

class StackOverFlow(object):

    def __init__(self):
        global bla
        bla.where()

# ... et maintenant vous pouvez créer une instance ------

answer = StackOverFlow()
# La astuce est d'utiliser global!