Comment puis-je obtenir le chemin d'accès et nom du fichier qui est en cours d'exécution?

J'ai des scripts de l'appel à d'autres fichiers de script mais j'ai besoin d'obtenir le chemin d'accès du fichier qui est actuellement en cours d'exécution dans le processus.

Par exemple, disons que j'ai trois fichiers. À l'aide de execfile:

script_1.py appels script_2.py.
À son tour, script_2.py appels script_3.py.

Comment puis-je obtenir le nom de fichier et le chemin d'accès de script_3.py, de code dans script_3.py, sans avoir à passer que l'information en tant qu'arguments de script_2.py?

(Exécution os.getcwd() renvoie l'original script de démarrage du chemin d'accès le fichier.)

Connexes: Python __file__ attribut absolu ou relatif?
os.chemin d'accès.la fonction realpath(fichier)
connexes: Comment déterminer correctement répertoire du script courant?

InformationsquelleAutor Ray Vega | 2008-09-08

240

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
```
- quand je fais inspect.getfile(inspect.currentframe()), il me donne le chemin complet du fichier en cours de traitement. Donc je ne suis pas sûr de ce que tu veux dire, ou sous quelles conditions ce ne serait pas donner le nom et le chemin d'accès".
- Il n'? Pas pour moi, et quelques autres par le regard de celui-ci. La deuxième ligne qui a été ajouté à la réponse que fournit le chemin d'accès complet si
- ATTENTION: Cet appel ne donne pas le même résultat avec des environnements différents. Envisager d'accepter Usagi réponse ci-dessous: stackoverflow.com/a/6628348/851398
- Pourriez-vous me donner un exemple? J'ai répondu question similaire, à l'aide de inspect.getabsfile() et il a travaillé pour tous les cas que j'ai essayé.
- Est en effet @Usagi répondre mieux?
- nah user13993 cloué, il est beaucoup mieux
- user13993 a en effet un clou. Devrait être os.path.realpath(__file__)
- user13933 méthode donne-moi le nom de l'appelant ne l'a appelé. C'est juste pour la question posée.
- vous faire comprendre que __file__ ne fonctionne pas avec execfile() qui est explicitement mentionné dans la question.
- Alors que les fichier est généralement assez bon, il l'habitude de travailler quand vous de votre programme est en cours d'exécution quelque part, loin de fichier.
- inspect.getfile() renvoie la __file__ attribut si passé un module objet. inspect.currentframe() renvoie le module. Ergo, c'est un moyen coûteux de dire __file__.
InformationsquelleAutor Pat Notz
538
```
__file__
```
comme d'autres l'ont dit. Vous pouvez également utiliser os.chemin d'accès.realpath pour éliminer les liens symboliques:
```
import os

os.path.realpath(__file__)
```
- On doit être prudent avec cette approche, car parfois __file__ renvoie 'script_name.py et d'autres fois 'script_name.pyc'. Si la sortie n'est pas stable.
- Mais puisque nous sommes seulement à l'aide du chemin d'accès de ce fichier qui est sans importance.
- c'est étrange: lors de l'exécution en ligne de commande "__file__" entre guillemets (comme une chaîne de caractères) donne la dir à partir de laquelle cmd est exécuté, mais __file__ (sans les guillemets donne le chemin d'accès au fichier source ... pourquoi est-ce que
- il n'y a pas de vérification de savoir si un nom de fichier de chaîne de caractères passée en existe, et depuis les chemins de fichiers sont par rapport à la mdc, c'est ce que le os.path.realpath fonction suppose la dir partie de la voie de l'être. os.path.dirname(os.path.realpath(__file__)) retourne répertoire avec le fichier. os.path.dirname(os.path.realpath("__file__")) renvoie la mdc. os.path.dirname(os.path.realpath("here_be_dragons")) retourne également la mdc.
InformationsquelleAutor user13993

Mise à jour 2018-11-28:

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

main.py - fonctionne foo.py

foo.py - fonctionne lib/bar.py

lib/bar.py - imprime filepath expressions

| 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 pour passer les paquets pouvez utiliser from lib import bar - il suffit d'ajouter vide __init__.py fichiers pour les deux dossiers.

Pour Python 3, execfile n'existe pas - le plus proche alternative est exec(open(<filename>).read()), bien que cela affecte la pile d'images. Il est plus simple d'utiliser import foo et import lib.bar - pas de __init__.py les fichiers nécessaires.

Voir aussi La différence entre l'importation et l'execfile

Réponse Originale À Cette Question:

Ici est une expérience basée sur les réponses dans ce fil - avec Python 2.7.10 sur Windows.

La pile, ceux sont les seuls qui semblent donner des résultats fiables. Les deux dernières ont la plus courte de la syntaxe, 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 pour ceux-ci étant ajoutés à sys comme des fonctions! Crédit @Usagi et @pablog

Basé sur les trois fichiers suivants, et en cours d'exécution main.py de son dossier avec python main.py (également essayé execfiles avec des chemins absolus et appeler à 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

InformationsquelleAutor Brian Burns

69

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 courante dans la pile (en haut de la pile) et [1] pour le nom de fichier, l'augmentation de revenir en arrière dans la pile, c'est à dire
```
print inspect.stack()[1][1]
```
serait le nom de fichier du script qui appelle l'image en cours. Aussi, à l'aide de [-1] vous rendre sur le bas de la pile, l'original script d'appel.
- Ne recommande pas de se fier sur la position à l'intérieur de la n-uplet. Il n'est pas clair à toutes les données que vous essayez d'obtenir lors de la lecture du code.
- inspect.getfile() renvoie la __file__ attribut si passé un module objet. inspect.currentframe() renvoie le module. Ergo, c'est un moyen coûteux de dire __file__.
- inspect.stack() est assez cher fonction, plus que juste inspect.currentframe(), et il fait aussi appel inspect.getfile() sur un objet module.
InformationsquelleAutor Usagi
40
```
import os
os.path.dirname(__file__) # relative directory path
os.path.abspath(__file__) # absolute file path
os.path.basename(__file__) # the file name only
```
- J'ai juste essayé de @Pat Notz commentaire. Je pense que vous pourriez juste obtenir le nom de fichier par le biais de __file__.
InformationsquelleAutor Neal Xiong
37

Les suggestions marqué comme meilleure sont tous vrai si votre script se compose d'un seul fichier.

Si vous souhaitez trouver le nom de l'exécutable (c'est à dire la racine du fichier transmis à l'interpréteur python pour le programme actuel) à partir d'un fichier qui peut être importé en tant que module, vous avez besoin pour ce faire (imaginons que c'est 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 est entré en elle (les piles sont LIFO/FILO structures de données).

Puis dans le fichier bar.py si vous import foo il va imprimer bar.py, plutôt que de foo.py, qui serait la valeur de l'ensemble de ces:
- __file__
- inspect.getfile(inspect.currentframe())
- inspect.stack()[0][1]
- Il fonctionne bien, mais pas pour le test unitaire sur eclipse, j'ai eu /home/utilisateur/Logiciels/eclipse/plugins/org.python.pydev_4.5.5.201603221110/pysrc
- C'est un moyen coûteux de l'orthographe sys.modules['__main__'].__file__, vraiment.
InformationsquelleAutor
13
```
import os
print os.path.basename(__file__)
```
cela nous donnera le nom du fichier uniquement. c'est à dire si abspath de fichier est c:\abcd\abc.py puis la 2ème ligne d'impression abc.py

InformationsquelleAutor vishal ekhe
12

Ce n'est pas tout à fait clair ce que tu veux dire par "le chemin du fichier qui est actuellement en cours d'exécution dans le processus".
sys.argv[0] contient généralement l'emplacement du script qui a été invoquée par l'interpréteur Python.
De vérifier la sys de la documentation pour plus de détails.

Comme @Tim et @Pat Notz l'avez souligné, l' __fichier__ attribut permet d'accéder à

le fichier à partir de laquelle le module a été
chargé, si il a été chargé à partir d'un fichier
- "imprimer des os.chemin d'accès.abspath( fichier )" et "imprimer les inspecter.getfile( inspection.currentframe() )" ne fonctionne pas quand on passe le programme en python pour un win32 exe. Seulement sys.argv[0] œuvres! 🙂 mais vous ne obtenez le nom!
InformationsquelleAutor Blair Conrad
10

J'ai un script qui doit fonctionner sous environnement windows.
Ce code ciselée est ce que j'ai fini avec:
```
import os,sys
PROJECT_PATH = os.path.abspath(os.path.split(sys.argv[0])[0])
```
il est tout à fait un hacky décision. Mais il ne nécessite pas de bibliothèques externes et c'est la chose la plus importante dans mon cas.
- J'ai eu à "import os, sys" pour cela, mais jusqu'à présent, c'est la meilleure réponse qui renvoie en fait juste le chemin sans nom de fichier à la fin de la chaîne.
InformationsquelleAutor garmoncheg
8
```
import os
os.path.dirname(os.path.abspath(__file__))
```
Pas besoin pour inspecter ou de toute autre bibliothèque.

Cela a fonctionné pour moi lorsque j'ai eu à l'importation d'un script (à partir d'un répertoire différent de l'exécution du script), qui utilise un fichier de configuration résidant dans le même dossier que le script importé.
- Cela ne produira pas la réponse souhaitée si le répertoire de travail courant (os.getcwd) est différent du répertoire dans lequel se trouve le fichier.
- Comment alors? Fonctionne très bien pour moi dans ce cas. Je reçois le répertoire dans lequel le fichier est situé dans.
- peut-être que cette réponse va vous aider avec ce que vous avez besoin. stackoverflow.com/a/41546830/3123191
InformationsquelleAutor Kwuite
8

La __file__ attribut fonctionne pour le fichier contenant les principaux exécution de code ainsi que des modules importés.

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

InformationsquelleAutor Readonly
6
```
import sys
print sys.path[0]
```
ce serait d'imprimer le chemin d'accès du script en cours d'exécution
- sys.chemin[0] est très utile, mais il donne le chemin d'accès de script1, pas script3 comme demandé
- Au moins sur OS X, avec 2.7, je ne trouve pas que cela n'a rien de fiable. Des travaux s'exécutant directement le même fichier. Ne fonctionne pas à partir de repl, surtout importé à partir d'un œuf
InformationsquelleAutor appusajeev

Essayer cela,

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

InformationsquelleAutor Soumyajit

5

Je pense que c'est juste __file__ dirait que vous voulez également à la caisse de la inspecter module.
- Ahhh... execfile est délicate. Voir mon autre post sur l'utilisation de l'inspecter module.
InformationsquelleAutor Pat Notz

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'

InformationsquelleAutor PabloG

3
```
import sys
print sys.argv[0]
```
- Malheureusement, cela ne fonctionne que si le script a été appelé avec son chemin d'accès complet, parce qu'il ne renvoie que le "premier" argument sur la ligne de commande, ce qui est de l'appel au script.
InformationsquelleAutor WBAR

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

InformationsquelleAutor Jahid

2
```
print(__file__)
print(__import__("pathlib").Path(__file__).parent)
```
- Code seulement les réponses sont découragés. S'il vous plaît ajouter quelques explications sur la façon dont cela résout le problème, ou comment elle diffère de la les réponses existantes. Revue
InformationsquelleAutor BaiJiFeiLong
1

Pour obtenir le répertoire de l'exécution du script
```
 print os.path.dirname( inspect.getfile(inspect.currentframe()))
```
InformationsquelleAutor pbaranski
0

J'ai utilisé l'approche par __fichier__

os.path.abspath(__file__)

mais il existe une petite astuce, il renvoie la .py fichier
lorsque le code est exécuté la première fois,
exécute ensuite donner le nom de *.pyc fichier

alors je suis resté avec:

inspect.getfile(inspect.currentframe())

ou

sys._getframe().f_code.co_filename

InformationsquelleAutor mik80

J'ai écrit une fonction qui tiennent compte de l'éclipse débogueur et unittest.
Retourner le dossier de la première script de lancement. Vous pouvez éventuellement spécifier le __fichier__ var, mais la chose principale est que vous n'avez pas à partager cette variable sur l'ensemble de vos l'appel de la hiérarchie.

Peut-être que vous pouvez gérer d'autres la pile cas particulier je n'ai pas vu, mais pour moi c'est ok.

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

InformationsquelleAutor hayj

0

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

path = r'%s' % os.getcwd().replace('\\','/')
- Ce qui est faux. Cela vous obtient le chemin d'accès actuel, mais pas le chemin d'accès du fichier en cours.
InformationsquelleAutor Qiao Zhang
0

Façon la plus simple est:

dans script_1.py:
```
import subprocess
subprocess.call(['python3',<path_to_script_2.py>])
```
dans script_2.py:
```
sys.argv[0]
```
P. S.: j'ai essayé de execfile, mais depuis qu'il lit script_2.py comme une chaîne de caractères, sys.argv[0] retourné <string>.

InformationsquelleAutor Lucas Azevedo
0

Voici ce que j'utilise donc je peux jeter mon code n'importe où sans problème. __name__ est toujours défini, mais __file__ est défini uniquement lorsque le code est exécuté en tant que fichier (par exemple, pas en VEILLE/iPython).
```
    if '__file__' in globals():
self_name = globals()['__file__']
elif '__file__' in locals():
self_name = locals()['__file__']
else:
self_name = __name__
```
Sinon, cela peut être écrite comme suit:
```
self_name = globals().get('__file__', locals().get('__file__', __name__))
```
InformationsquelleAutor craymichael
-1

J'ai toujours utilisé le système d'exploitation disposent de Répertoire de Travail Courant, ou de la MDC. Cela fait partie de la bibliothèque standard, et est très facile à mettre en œuvre.
Voici un exemple:
```
    import os
base_directory = os.getcwd()
```
- Pourriez-vous modifier votre réponse afin qu'elle s'applique à la question posée? Cette réponse ne s'applique pas à la question "Comment puis-je obtenir le chemin d'accès et le nom de du fichier qui est en cours d'exécution?"
- Cela donne le chemin d'où vous avez exécuté la commande python. Il semble donc que le travail lorsque vous exécutez la python script.py commande dans le même dossier que vous êtes déjà, alors qu'en réalité c'est la même que l'exécution de pwd sur linux.
InformationsquelleAutor Ethan J.

-2

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

Donc ce score élevé de réponse 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

InformationsquelleAutor user3339488

-3

si vous voulez simplement le nom de fichier sans ./ ou .py vous pouvez essayer ce
```
filename = testscript.py
file_name = __file__[2:-3]
```
file_name imprime testscript
vous pouvez générer tout ce que vous voulez par l'évolution de l'indice à l'intérieur de []

InformationsquelleAutor sapam
-3
```
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)
```
- os.getcwd() retourne le répertoire de TRAVAIL courant du PROCESSUS, et non pas le répertoire de l'exécution actuelle de fichier. Cela peut sembler renvoyer des résultats corrects, mais il y a beaucoup de cas où le résultat ne serait pas le fichier actuel du répertoire parent. Beaucoup mieux d'utiliser os.chemin d'accès.dirname(fichier) comme suggéré ci-dessus.
InformationsquelleAutor jscabuzzo

Vous devez vous connecter pour publier un commentaire.