Pode parecer uma pergunta para iniciantes, mas não é. Algumas abordagens comuns não funcionam em todos os casos:

sys.argv [0]

Isso significa usar path = os.path.abspath(os.path.dirname(sys.argv[0])), mas isso não funciona se você estiver executando em outro script Python em outro diretório, e isso pode acontecer na vida real.

__Arquivo__

Isso significa usar path = os.path.abspath(os.path.dirname(__file__)), mas descobri que isso não funciona:

• py2exenão tem um __file__atributo, mas há uma solução alternativa
• Quando você executa a partir do IDLE com execute()nenhum __file__atributo
• OS X 10.6 onde eu recebo NameError: global name '__file__' is not defined

Perguntas relacionadas com respostas incompletas:

• Python - Encontre o caminho para o arquivo sendo executado
• O caminho para o arquivo atual depende de como eu executo o programa
• Como saber o caminho do script em execução no Python?
• Mude o diretório para o diretório de um script Python

Estou procurando uma solução genérica , que funcionaria em todos os casos de uso acima.

Atualizar

Aqui está o resultado de um testcase:

Saída de python a.py (no 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

árvore

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

Você não pode determinar diretamente a localização do script principal que está sendo executado. Afinal, às vezes o script não veio de um arquivo. Por exemplo, poderia vir do intérprete interativo ou do código gerado dinamicamente, armazenado apenas na memória.

No entanto, você pode determinar com segurança a localização de um módulo, pois os módulos sempre são carregados de um arquivo. Se você criar um módulo com o código a seguir e colocá-lo no mesmo diretório que o script principal, o script principal poderá importar o módulo e usá-lo para se localizar.

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

Se você tiver vários scripts principais em diretórios diferentes, poderá precisar de mais de uma cópia do module_locator.

Obviamente, se o seu script principal for carregado por alguma outra ferramenta que não permita a importação de módulos co-localizados com o seu script, você estará sem sorte. Em casos como esse, as informações que você procura simplesmente não existem em nenhum lugar do seu programa. Sua melhor aposta seria registrar um bug com os autores da ferramenta.

Primeiro, você precisa importar de inspecteos

from inspect import getsourcefile
from os.path import abspath

Em seguida, onde você quiser encontrar o arquivo de origem, basta usar

abspath(getsourcefile(lambda:0))

essa solução é robusta mesmo em executáveis

import inspect, os.path

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

Eu estava com um problema semelhante e acho que isso pode resolver o 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))

Funciona para scripts regulares e inativos. Tudo o que posso dizer é experimentá-lo para os outros!

Meu uso típico:

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

global __modpath__
__modpath__ = module_path(main)

Agora eu uso __modpath__ em vez de __file__.

A resposta curta é que não há maneira garantida de obter as informações desejadas , no entanto, existem heurísticas que funcionam quase sempre na prática. Você pode ver Como encontro a localização do executável em C? . Ele discute o problema do ponto de vista C, mas as soluções propostas são facilmente transcritas para o Python.

Consulte minha resposta para a pergunta Importando módulos da pasta pai para obter informações relacionadas, incluindo por que minha resposta não usa a __file__variável não confiável . Essa solução simples deve ser compatível com diferentes sistemas operacionais como módulos ose inspectfazer parte do Python.

Primeiro, você precisa importar partes dos módulos inspecionar e os .

from inspect import getsourcefile
from os.path import abspath

Em seguida, use a seguinte linha em qualquer outro local necessário no seu código Python:

abspath(getsourcefile(lambda:0))

Como funciona:

Do módulo interno os(descrição abaixo), a abspathferramenta é importada.

Rotinas de SO para Mac, NT ou Posix, dependendo do sistema em que estamos.

Em seguida getsourcefile(descrição abaixo) é importada do módulo interno inspect.

Obtenha informações úteis de objetos Python ao vivo.

• abspath(path) retorna a versão absoluta / completa de um caminho de arquivo
• getsourcefile(lambda:0)de alguma maneira obtém o arquivo de origem interno do objeto da função lambda, então retorna '<pyshell#nn>'no shell do Python ou retorna o caminho do arquivo do código Python atualmente sendo executado.

A utilização abspathdo resultado de getsourcefile(lambda:0)deve garantir que o caminho do arquivo gerado seja o caminho completo do arquivo Python.
Esta solução explicada foi originalmente baseada no código da resposta em Como obtenho o caminho do arquivo executado atualmente no Python? .

Você simplesmente chamou:

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

ao invés de:

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

abspath()fornece o caminho absoluto de sys.argv[0](o nome do arquivo em que seu código está) e dirname()retorna o caminho do diretório sem o nome do arquivo.

Isso deve funcionar de uma maneira multiplataforma (desde que você não esteja usando o intérprete ou algo assim):

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]é o diretório em que o script de chamada está (o primeiro lugar em que ele procura módulos a serem usados ​​por esse script). Podemos tirar o nome do arquivo em si (no final, sys.argv[0]fiz o que fiz os.path.basename). os.path.joinapenas os junta de uma maneira multiplataforma. os.path.realpathapenas garante que, se obtivermos links simbólicos com nomes diferentes do script em si, ainda assim obtemos o nome real do script.

Eu não tenho um Mac; então, eu não testei isso em um. Por favor, deixe-me saber se funciona, como parece que deveria. Eu testei isso no Linux (Xubuntu) com Python 3.4. Observe que muitas soluções para esse problema não funcionam em Macs (já que ouvi dizer que __file__não está presente em Macs).

Observe que, se seu script for um link simbólico, ele fornecerá o caminho do arquivo ao qual ele vincula (e não o caminho do link simbólico).

Você pode usar Pathno pathlibmódulo:

from pathlib import Path

# ...

Path(__file__)

Você pode usar call parentpara ir mais longe no caminho:

Path(__file__).parent

Se o código vier de um arquivo, você poderá obter o nome completo

sys._getframe().f_code.co_filename

Você também pode recuperar o nome da função como f_code.co_name

Basta adicionar o seguinte:

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

Ou:

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

Minha solução é:

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

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