Cela peut sembler une question pour les débutants, mais ce n'est pas le cas. Certaines approches courantes ne fonctionnent pas dans tous les cas:

sys.argv [0]

Cela signifie utiliser path = os.path.abspath(os.path.dirname(sys.argv[0])), mais cela ne fonctionne pas si vous exécutez à partir d'un autre script Python dans un autre répertoire, et cela peut arriver dans la vraie vie.

__fichier__

Cela signifie utiliser path = os.path.abspath(os.path.dirname(__file__)), mais j'ai trouvé que cela ne fonctionne pas:

• py2exen'a pas d' __file__attribut, mais il existe une solution de contournement
• Lorsque vous exécutez à partir de IDLE execute()sans __file__attribut
• OS X 10.6 où j'obtiens NameError: global name '__file__' is not defined

Questions connexes avec des réponses incomplètes:

• Python - Trouver le chemin du fichier en cours d'exécution
• Le chemin vers le fichier actuel dépend de la façon dont j'exécute le programme
• Comment 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

Je recherche une solution générique , qui fonctionnerait dans tous les cas d'utilisation ci-dessus.

Mettre à jour

Voici le résultat d'un testcase:

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

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

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

arbre

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

Vous ne pouvez pas déterminer directement l'emplacement du script principal en cours d'exécution. Après tout, parfois, le script ne provenait pas du tout d'un fichier. Par exemple, il peut provenir de l'interpréteur interactif ou d'un 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, le script principal peut importer le module et l'utiliser pour se localiser.

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()

Si vous avez plusieurs scripts principaux dans différents répertoires, vous aurez peut-être 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 co-localisés avec votre script, alors vous n'avez pas de chance. Dans de tels cas, les informations que vous recherchez n'existent tout simplement nulle part dans votre programme. Votre meilleur pari serait de déposer un bug auprès des auteurs de l'outil.

Tout d'abord, vous devez importer depuis inspectetos

from inspect import getsourcefile
from os.path import abspath

Ensuite, où que vous vouliez trouver le fichier source, utilisez simplement

abspath(getsourcefile(lambda:0))

cette solution est robuste même dans les exécutables

import inspect, os.path

filename = inspect.getframeinfo(inspect.currentframe()).filename
path     = os.path.dirname(os.path.abspath(filename))

Je rencontrais un problème similaire, et je pense que cela pourrait résoudre le problème:

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))

Cela fonctionne pour les scripts réguliers et en veille. Tout ce que je peux dire, c'est de l'essayer pour les autres!

Mon utilisation typique:

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

global __modpath__
__modpath__ = module_path(main)

Maintenant, j'utilise __modpath__ au lieu de __file__.

La réponse courte est qu'il n'y a pas de moyen garanti d'obtenir les informations souhaitées , mais il existe des heuristiques qui fonctionnent presque toujours dans la pratique. Vous pourriez regarder Comment puis-je 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 sont facilement transcrites en Python.

Voir ma réponse à la question Importer des modules à partir du dossier parent pour des informations connexes, y compris pourquoi ma réponse n'utilise pas la __file__variable non fiable . Cette solution simple doit être compatible avec différents systèmes d'exploitation comme les modules oset inspectfaire partie de Python.

Tout d' abord, vous devez parties à l'importation de l' inspectent et os modules.

from inspect import getsourcefile
from os.path import abspath

Ensuite, utilisez la ligne suivante partout ailleurs dans votre code Python:

abspath(getsourcefile(lambda:0))

Comment ça fonctionne:

Depuis le module intégré os(description ci-dessous), l' abspathoutil est importé.

Routines du système d'exploitation pour Mac, NT ou Posix selon le système sur lequel nous sommes.

Ensuite getsourcefile(description ci-dessous) est importé du module intégré inspect.

Obtenez des informations utiles à partir d'objets Python en direct.

• abspath(path) renvoie la version absolue / complète d'un chemin de fichier
• getsourcefile(lambda:0)obtient en quelque sorte le fichier source interne de l'objet de la fonction lambda, donc retourne '<pyshell#nn>'dans le shell Python ou retourne le chemin du fichier du code Python en cours d'exécution.

En utilisant abspathle résultat de, getsourcefile(lambda:0)vous devez vous assurer que le chemin du fichier généré est le chemin complet du fichier Python.
Cette solution expliquée était à l'origine basée sur le code de la réponse à Comment obtenir le chemin du fichier actuellement exécuté en Python? .

Vous avez simplement appelé:

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

au lieu de:

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

abspath()vous donne le chemin absolu de sys.argv[0](le nom de fichier dans lequel se trouve votre code) et dirname()renvoie le chemin du répertoire sans le nom de fichier.

Cela devrait faire l'affaire de manière multiplateforme (tant que vous n'utilisez pas l'interpréteur ou quelque chose):

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]est le répertoire dans lequel se trouve votre script appelant (le premier endroit où il recherche les modules à utiliser par ce script). Nous pouvons prendre le nom du fichier lui-même à la fin de sys.argv[0](ce que j'ai fait avec os.path.basename). os.path.joinles colle simplement ensemble de manière multiplateforme. os.path.realpaths'assure simplement que si nous obtenons des liens symboliques avec des noms différents de ceux du script lui-même, nous obtenons toujours le vrai nom du script.

Je n'ai pas de Mac; donc, je ne l'ai pas testé sur un seul. S'il vous plaît laissez-moi savoir si cela fonctionne, comme il semble que cela devrait. J'ai testé cela sous Linux (Xubuntu) avec Python 3.4. Notez que de nombreuses solutions à ce problème ne fonctionnent pas sur les Mac (depuis que j'ai entendu dire que ce __file__n'est pas présent sur les Mac).

Notez que si votre script est un lien symbolique, il vous donnera le chemin du fichier vers lequel il est lié (et non le chemin du lien symbolique).

Vous pouvez utiliser à Pathpartir du pathlibmodule:

from pathlib import Path

# ...

Path(__file__)

Vous pouvez utiliser l'appel à parentpour aller plus loin dans le chemin:

Path(__file__).parent

Si le code provient d'un fichier, vous pouvez obtenir son nom complet

sys._getframe().f_code.co_filename

Vous pouvez également récupérer le nom de la fonction sous la forme f_code.co_name

Ajoutez simplement ce qui suit:

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

Ou:

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

Ma solution est:

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

import os
current_file_path=os.path.dirname(os.path.realpath('__file__'))