Potrebbe sembrare una domanda da principiante, ma non lo è. Alcuni approcci comuni non funzionano in tutti i casi:

sys.argv [0]

Questo significa usare path = os.path.abspath(os.path.dirname(sys.argv[0])), ma non funziona se stai eseguendo un altro script Python in un'altra directory, e questo può accadere nella vita reale.

__file__

Questo significa usare path = os.path.abspath(os.path.dirname(__file__)), ma ho scoperto che non funziona:

• py2exenon ha un __file__attributo, ma esiste una soluzione alternativa
• Quando si esegue da IDLE con execute()non esiste alcun __file__attributo
• OS X 10.6 dove ottengo NameError: global name '__file__' is not defined

Domande correlate con risposte incomplete:

• Python: trova il percorso del file in esecuzione
• Il percorso del file corrente dipende da come eseguo il programma
• Come conoscere il percorso dello script in esecuzione in Python?
• Cambia la directory nella directory di uno script Python

Sto cercando soluzione generica , che funzioni in tutti i casi d'uso sopra indicati.

Aggiornare

Ecco il risultato di una prova:

Output di python a.py (su 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

albero

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

Non è possibile determinare direttamente la posizione dello script principale in esecuzione. Dopotutto, a volte lo script non proveniva affatto da un file. Ad esempio, potrebbe provenire dall'interprete interattivo o dal codice generato dinamicamente e archiviato solo in memoria.

Tuttavia, è possibile determinare in modo affidabile la posizione di un modulo, poiché i moduli vengono sempre caricati da un file. Se si crea un modulo con il seguente codice e lo si inserisce nella stessa directory dello script principale, lo script principale può importare il modulo e utilizzarlo per localizzarsi.

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

QUALCHE_PERCORSO / main.py:

import module_locator
my_path = module_locator.module_path()

Se hai diversi script principali in directory diverse, potresti aver bisogno di più di una copia di module_locator.

Ovviamente, se il tuo script principale è caricato da qualche altro strumento che non ti consente di importare moduli che si trovano nello stesso luogo, allora sei sfortunato. In casi del genere, le informazioni che cerchi semplicemente non esistono in nessun punto del tuo programma. La soluzione migliore sarebbe quella di presentare un bug con gli autori dello strumento.

Innanzitutto, è necessario importare da inspecteos

from inspect import getsourcefile
from os.path import abspath

Successivamente, ovunque tu voglia trovare il file sorgente da te, basta usare

abspath(getsourcefile(lambda:0))

questa soluzione è solida anche negli eseguibili

import inspect, os.path

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

Stavo riscontrando un problema simile e penso che questo potrebbe risolvere il problema:

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

Funziona con script regolari e inattivo. Tutto quello che posso dire è provarlo per gli altri!

Il mio uso tipico:

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

global __modpath__
__modpath__ = module_path(main)

Ora uso __modpath__ invece di __file__.

La risposta breve è che non esiste un modo garantito per ottenere le informazioni desiderate , tuttavia ci sono euristiche che funzionano quasi sempre nella pratica. Potresti guardare Come posso trovare la posizione dell'eseguibile in C? . Discute il problema da un punto di vista C, ma le soluzioni proposte sono facilmente trascritte in Python.

Vedi la mia risposta alla domanda Importazione di moduli dalla cartella principale per informazioni correlate, incluso il motivo per cui la mia risposta non utilizza la __file__variabile inaffidabile . Questa semplice soluzione dovrebbe essere compatibile con diversi sistemi operativi come i moduli ose far inspectparte di Python.

In primo luogo, è necessario parti dell'importazione del ispezionare e os moduli.

from inspect import getsourcefile
from os.path import abspath

Quindi, usa la seguente riga in qualsiasi altro punto del codice Python:

abspath(getsourcefile(lambda:0))

Come funziona:

Dal modulo integrato os(descrizione sotto), lo abspathstrumento viene importato.

Routine OS per Mac, NT o Posix a seconda del sistema in uso.

Quindi getsourcefile(descrizione in basso) viene importato dal modulo integrato inspect.

Ottieni informazioni utili dagli oggetti live di Python.

• abspath(path) restituisce la versione assoluta / completa di un percorso di file
• getsourcefile(lambda:0)in qualche modo ottiene il file sorgente interno dell'oggetto funzione lambda, quindi ritorna '<pyshell#nn>'nella shell Python o restituisce il percorso del file del codice Python attualmente in esecuzione.

L'utilizzo abspathsul risultato di getsourcefile(lambda:0)dovrebbe assicurarsi che il percorso del file generato sia il percorso completo del file Python.
Questa soluzione spiegata era originariamente basata sul codice della risposta in Come posso ottenere il percorso del file attualmente eseguito in Python? .

Hai semplicemente chiamato:

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

invece di:

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

abspath()ti dà il percorso assoluto di sys.argv[0](il nome del file in cui si trova il tuo codice) e dirname()restituisce il percorso della directory senza il nome del file.

Questo dovrebbe fare il trucco in un modo multipiattaforma (purché non si usi l'interprete o qualcosa del genere):

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]è la directory in cui si trova lo script chiamante (il primo posto in cui cerca i moduli che devono essere utilizzati da quello script). Possiamo prendere il nome del file stesso alla fine di sys.argv[0](che è quello che ho fatto con os.path.basename). os.path.joinli unisce semplicemente in modo multipiattaforma.os.path.realpathsolo assicurati che se otteniamo collegamenti simbolici con nomi diversi dallo script stesso, otteniamo ancora il vero nome dello script.

Non ho un Mac; quindi, non ho provato questo su uno. Per favore fatemi sapere se funziona, come sembra che dovrebbe. Ho provato questo in Linux (Xubuntu) con Python 3.4. Nota che molte soluzioni a questo problema non funzionano sui Mac (poiché ho sentito che __file__non è presente sui Mac).

Nota che se lo script è un link simbolico, ti darà il percorso del file a cui si collega (e non il percorso del link simbolico).

È possibile utilizzare Pathdal pathlibmodulo:

from pathlib import Path

# ...

Path(__file__)

Puoi usare call to parentper andare oltre nel percorso:

Path(__file__).parent

Se il codice proviene da un file, è possibile ottenere il nome completo

sys._getframe().f_code.co_filename

È inoltre possibile recuperare il nome della funzione come f_code.co_name

Aggiungi semplicemente quanto segue:

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

O:

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

La mia soluzione è:

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

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