Comment obtenir le chemin et le nom du fichier en cours d'exécution?

J'ai des scripts appelant d'autres fichiers de script, mais j'ai besoin d'obtenir le chemin du fichier en cours d'exécution dans le processus.

Par exemple, supposons que j'ai trois fichiers. Utiliser execfile :

• script_1.pyles appels script_2.py.
• À son tour, les script_2.pyappels script_3.py.

Comment puis-je obtenir le nom et le chemin du fichier script_3.py, à partir du code à l'intérieurscript_3.py , sans avoir à transmettre ces informations comme arguments script_2.py?

(L'exécution os.getcwd()renvoie le chemin de fichier du script de démarrage d'origine et non celui du fichier en cours.)

p1.py:

execfile("p2.py")

p2.py:

import inspect, os
print (inspect.getfile(inspect.currentframe()) # script filename (usually with path)
print (os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe())))) # script directory

__file__

comme d'autres l'ont dit. Vous pouvez également utiliser os.path.realpath pour éliminer les liens symboliques:

import os

os.path.realpath(__file__)

Mise à jour 2018-11-28:

Voici un résumé des expériences avec Python 2 et 3. Avec

main.py - exécute foo.py
foo.py - exécute lib / bar.py
lib / bar.py - imprime les expressions de chemin de fichier

| Python | Run statement       | Filepath expression                    |
|--------+---------------------+----------------------------------------|
|      2 | execfile            | os.path.abspath(inspect.stack()[0][1]) |
|      2 | from lib import bar | __file__                               |
|      3 | exec                | (wasn't able to obtain it)             |
|      3 | import lib.bar      | __file__                               |

Pour Python 2, il peut être plus clair de passer aux packages, vous pouvez donc l'utiliser from lib import bar- ajoutez simplement des __init__.pyfichiers vides aux deux dossiers.

Pour Python 3, execfilen'existe pas - l'alternative la plus proche est exec(open(<filename>).read()), bien que cela affecte les cadres de pile. Il est plus simple à utiliser import fooet import lib.bar- aucun __init__.pyfichier n'est nécessaire.

Voir aussi Différence entre import et execfile

Réponse originale:

Voici une expérience basée sur les réponses de ce fil - avec Python 2.7.10 sous Windows.

Les piles basées sur la pile sont les seules qui semblent donner des résultats fiables. Les deux derniers ont la syntaxe la plus courte , c'est-à-dire -

print os.path.abspath(inspect.stack()[0][1])                   # C:\filepaths\lib\bar.py
print os.path.dirname(os.path.abspath(inspect.stack()[0][1]))  # C:\filepaths\lib

Voici à ces ajouts à sys en tant que fonctions! Crédit à @Usagi et @pablog

Sur la base des trois fichiers suivants, et en exécutant main.py à partir de son dossier avec python main.py(également des fichiers exécutés essayés avec des chemins absolus et appelant à partir d'un dossier séparé).

C: \ filepaths \ main.py: execfile('foo.py')
C: \ filepaths \ foo.py: execfile('lib/bar.py')
C: \ filepaths \ lib \ bar.py:

import sys
import os
import inspect

print "Python " + sys.version
print

print __file__                                        # main.py
print sys.argv[0]                                     # main.py
print inspect.stack()[0][1]                           # lib/bar.py
print sys.path[0]                                     # C:\filepaths
print

print os.path.realpath(__file__)                      # C:\filepaths\main.py
print os.path.abspath(__file__)                       # C:\filepaths\main.py
print os.path.basename(__file__)                      # main.py
print os.path.basename(os.path.realpath(sys.argv[0])) # main.py
print

print sys.path[0]                                     # C:\filepaths
print os.path.abspath(os.path.split(sys.argv[0])[0])  # C:\filepaths
print os.path.dirname(os.path.abspath(__file__))      # C:\filepaths
print os.path.dirname(os.path.realpath(sys.argv[0]))  # C:\filepaths
print os.path.dirname(__file__)                       # (empty string)
print

print inspect.getfile(inspect.currentframe())         # lib/bar.py

print os.path.abspath(inspect.getfile(inspect.currentframe())) # C:\filepaths\lib\bar.py
print os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe()))) # C:\filepaths\lib
print

print os.path.abspath(inspect.stack()[0][1])          # C:\filepaths\lib\bar.py
print os.path.dirname(os.path.abspath(inspect.stack()[0][1]))  # C:\filepaths\lib
print

Je pense que c'est plus propre:

import inspect
print inspect.stack()[0][1]

et obtient les mêmes informations que:

print inspect.getfile(inspect.currentframe())

Où [0] est l'image actuelle dans la pile (haut de la pile) et [1] pour le nom du fichier, augmentez pour revenir en arrière dans la pile, c.-à-d.

print inspect.stack()[1][1]

serait le nom de fichier du script qui a appelé l'image actuelle. De plus, l'utilisation de [-1] vous amènera au bas de la pile, le script d'appel d'origine.

import os
os.path.dirname(__file__) # relative directory path
os.path.abspath(__file__) # absolute file path
os.path.basename(__file__) # the file name only

Les suggestions marquées comme les meilleures sont toutes vraies si votre script se compose d'un seul fichier.

Si vous voulez connaître le nom de l'exécutable (c'est-à-dire le fichier racine passé à l'interpréteur python pour le programme actuel) à partir d'un fichier qui peut être importé en tant que module, vous devez le faire (supposons que cela se trouve dans un fichier nommé foo.py ):

import inspect

print inspect.stack()[-1][1]

Parce que la dernière chose ( [-1]) sur la pile est la première chose qui y est entrée (les piles sont des structures de données LIFO / FILO).

Ensuite, dans le fichier bar.py si vous import fooimprimez bar.py , plutôt que foo.py , qui serait la valeur de tous ces éléments:

• __file__
• inspect.getfile(inspect.currentframe())
• inspect.stack()[0][1]

import os
print os.path.basename(__file__)

cela nous donnera uniquement le nom du fichier. c'est-à-dire si l'abspath du fichier est c: \ abcd \ abc.py alors la deuxième ligne affichera abc.py

Il n'est pas tout à fait clair ce que vous entendez par "le chemin de fichier du fichier qui s'exécute actuellement dans le processus". sys.argv[0]contient généralement l'emplacement du script qui a été invoqué par l'interpréteur Python. Consultez la documentation sys pour plus de détails.

Comme l'ont souligné @Tim et @Pat Notz, l'attribut __file__ donne accès à

le fichier à partir duquel le module a été chargé, s'il a été chargé à partir d'un fichier

J'ai un script qui doit fonctionner sous environnement Windows. Ce code coupé est ce que j'ai fini avec:

import os,sys
PROJECT_PATH = os.path.abspath(os.path.split(sys.argv[0])[0])

c'est une décision assez bidon. Mais cela ne nécessite aucune bibliothèque externe et c'est la chose la plus importante dans mon cas.

Essaye ça,

import os
os.path.dirname(os.path.realpath(__file__))

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

Pas besoin d'inspecter ou de toute autre bibliothèque.

Cela a fonctionné pour moi lorsque j'ai dû importer un script (à partir d'un répertoire différent puis du script exécuté), qui utilisait un fichier de configuration résidant dans le même dossier que le script importé.

L' __file__attribut fonctionne à la fois pour le fichier contenant le code d'exécution principal ainsi que pour les modules importés.

Voir https://web.archive.org/web/20090918095828/http://pyref.infogami.com/__file__

import sys

print sys.path[0]

cela afficherait le chemin du script en cours d'exécution

Je pense que c'est juste __file__ comme si vous souhaitiez peut-être également vérifier le module d'inspection .

Vous pouvez utiliser inspect.stack()

import inspect,os
inspect.stack()[0]  => (<frame object at 0x00AC2AC0>, 'g:\\Python\\Test\\_GetCurrentProgram.py', 15, '<module>', ['print inspect.stack()[0]\n'], 0)
os.path.abspath (inspect.stack()[0][1]) => 'g:\\Python\\Test\\_GetCurrentProgram.py'

Étant donné que Python 3 est assez courant, je voulais inclure une pathlibréponse, car je pense que c'est probablement maintenant un meilleur outil pour accéder aux informations sur les fichiers et les chemins.

from pathlib import Path

current_file: Path = Path(__file__).resolve()

Si vous recherchez le répertoire du fichier en cours, c'est aussi simple que d'ajouter .parentà la Path()déclaration:

current_path: Path = Path(__file__).parent.resolve()

import sys
print sys.argv[0]

Cela devrait fonctionner:

import os,sys
filename=os.path.basename(os.path.realpath(sys.argv[0]))
dirname=os.path.dirname(os.path.realpath(sys.argv[0]))

print(__file__)
print(__import__("pathlib").Path(__file__).parent)

Pour obtenir le répertoire d'exécution du script

 print os.path.dirname( inspect.getfile(inspect.currentframe()))

J'ai toujours utilisé la fonction os de Current Working Directory, ou CWD. Cela fait partie de la bibliothèque standard et est très facile à implémenter. Voici un exemple:

    import os
    base_directory = os.getcwd()

J'ai utilisé l'approche avec __file__
os.path.abspath(__file__)
mais il y a une petite astuce, elle retourne le fichier .py lorsque le code est exécuté la première fois, les prochaines exécutions donnent le nom du fichier * .pyc
donc je suis resté avec:
inspect.getfile(inspect.currentframe())
ou
sys._getframe().f_code.co_filename

J'ai écrit une fonction qui prend en compte le débogueur d' éclipse et unittest . Il renvoie le dossier du premier script que vous lancez. Vous pouvez éventuellement spécifier la var __file__ , mais l'essentiel est que vous n'avez pas à partager cette variable dans toute votre hiérarchie d'appel .

Peut-être que vous pouvez gérer d'autres empiler des cas particuliers que je n'ai pas vus, mais pour moi, ça va.

import inspect, os
def getRootDirectory(_file_=None):
    """
    Get the directory of the root execution file
    Can help: http://stackoverflow.com/questions/50499/how-do-i-get-the-path-and-name-of-the-file-that-is-currently-executing
    For eclipse user with unittest or debugger, the function search for the correct folder in the stack
    You can pass __file__ (with 4 underscores) if you want the caller directory
    """
    # If we don't have the __file__ :
    if _file_ is None:
        # We get the last :
        rootFile = inspect.stack()[-1][1]
        folder = os.path.abspath(rootFile)
        # If we use unittest :
        if ("/pysrc" in folder) & ("org.python.pydev" in folder):
            previous = None
            # We search from left to right the case.py :
            for el in inspect.stack():
                currentFile = os.path.abspath(el[1])
                if ("unittest/case.py" in currentFile) | ("org.python.pydev" in currentFile):
                    break
                previous = currentFile
            folder = previous
        # We return the folder :
        return os.path.dirname(folder)
    else:
        # We return the folder according to specified __file__ :
        return os.path.dirname(os.path.realpath(_file_))

Pour conserver la cohérence de la migration entre les plates-formes (macOS / Windows / Linux), essayez:

path = r'%s' % os.getcwd().replace('\\','/')

Le moyen le plus simple est:

dans script_1.py:

import subprocess
subprocess.call(['python3',<path_to_script_2.py>])

dans script_2.py:

sys.argv[0]

PS: J'ai essayé execfile, mais comme il lit script_2.py sous forme de chaîne, je suis sys.argv[0]retourné <string>.

Voici ce que j'utilise pour pouvoir lancer mon code n'importe où sans problème. __name__est toujours défini, mais __file__n'est défini que lorsque le code est exécuté en tant que fichier (par exemple pas dans IDLE / iPython).

    if '__file__' in globals():
        self_name = globals()['__file__']
    elif '__file__' in locals():
        self_name = locals()['__file__']
    else:
        self_name = __name__

Alternativement, cela peut s'écrire:

self_name = globals().get('__file__', locals().get('__file__', __name__))

La plupart de ces réponses ont été écrites en Python version 2.x ou antérieure. Dans Python 3.x, la syntaxe de la fonction d'impression a changé pour exiger des parenthèses, c'est-à-dire print ().

Donc, cette réponse antérieure au meilleur score de user13993 en Python 2.x:

import inspect, os
print inspect.getfile(inspect.currentframe()) # script filename (usually with path)
print os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe()))) # script directory

Devient en Python 3.x:

import inspect, os
print(inspect.getfile(inspect.currentframe())) # script filename (usually with path)
print(os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe()))) ) # script directory

si vous voulez juste le nom de fichier sans ./ou .pyvous pouvez essayer ceci

filename = testscript.py
file_name = __file__[2:-3]

file_name affichera le script de test, vous pouvez générer ce que vous voulez en modifiant l'index à l'intérieur []

import os

import wx


# return the full path of this file
print(os.getcwd())

icon = wx.Icon(os.getcwd() + '/img/image.png', wx.BITMAP_TYPE_PNG, 16, 16)

# put the icon on the frame
self.SetIcon(icon)