O que é uma alternativa ao execfile no Python 3?

Parece que eles cancelaram no Python 3 toda a maneira fácil de carregar rapidamente um script removendo execfile()

Existe uma alternativa óbvia que estou perdendo?

De acordo com a documentação , em vez de

execfile("./filename") 

Usar

exec(open("./filename").read())

Vejo:

• O que há de novo no Python 3.0

Você deveria ler o arquivo e executar o código sozinho. A corrente 2to3 substitui

execfile("somefile.py", global_vars, local_vars)

Como

with open("somefile.py") as f:
    code = compile(f.read(), "somefile.py", 'exec')
    exec(code, global_vars, local_vars)

(A chamada de compilação não é estritamente necessária, mas associa o nome do arquivo ao objeto de código, facilitando um pouco a depuração.)

Vejo:

• http://docs.python.org/release/2.7.3/library/functions.html#execfile
• http://docs.python.org/release/3.2.3/library/functions.html#compile
• http://docs.python.org/release/3.2.3/library/functions.html#exec

Embora exec(open("filename").read())muitas vezes seja fornecido como uma alternativa execfile("filename"), ele perde detalhes importantes execfilesuportados.

A função a seguir para Python3.x é a mais próxima possível de ter o mesmo comportamento de executar um arquivo diretamente. Isso corresponde a correr python /path/to/somefile.py.

def execfile(filepath, globals=None, locals=None):
    if globals is None:
        globals = {}
    globals.update({
        "__file__": filepath,
        "__name__": "__main__",
    })
    with open(filepath, 'rb') as file:
        exec(compile(file.read(), filepath, 'exec'), globals, locals)

# execute the file
execfile("/path/to/somefile.py")

Notas:

• Usa leitura binária para evitar problemas de codificação
• Garantido para fechar o arquivo (Python3.x alerta sobre isso)
• Define __main__, alguns scripts dependem disso para verificar se estão carregando como um módulo ou não, por exemplo.if __name__ == "__main__"
• A configuração __file__é melhor para mensagens de exceção e alguns scripts são usados __file__para obter os caminhos de outros arquivos em relação a eles.

• Aceita argumentos globais e locais opcionais, modificando-os no local da mesma execfileforma - para que você possa acessar quaisquer variáveis ​​definidas lendo novamente as variáveis ​​após a execução.

• Ao contrário do Python2, execfileisso não modifica o namespace atual por padrão. Para isso, você deve passar explicitamente em globals()& locals().

Como sugerido recentemente na lista de discussão python-dev , o módulo runpy pode ser uma alternativa viável. Citando essa mensagem:

https://docs.python.org/3/library/runpy.html#runpy.run_path

import runpy
file_globals = runpy.run_path("file.py")

Existem diferenças sutis para execfile:

• run_pathsempre cria um novo espaço para nome. Ele executa o código como um módulo, portanto, não há diferença entre globais e locais (é por isso que existe apenas um init_globalsargumento). Os globais são retornados.

  execfileexecutado no espaço para nome atual ou no espaço para nome fornecido. A semântica de localse globals, se fornecida, era semelhante aos locais e globais dentro de uma definição de classe.

• run_path pode não apenas executar arquivos, mas também ovos e diretórios (consulte a documentação para obter detalhes).

Este é melhor, pois leva os globais e locais do chamador:

import sys
def execfile(filename, globals=None, locals=None):
    if globals is None:
        globals = sys._getframe(1).f_globals
    if locals is None:
        locals = sys._getframe(1).f_locals
    with open(filename, "r") as fh:
        exec(fh.read()+"\n", globals, locals)

Você pode escrever sua própria função:

def xfile(afile, globalz=None, localz=None):
    with open(afile, "r") as fh:
        exec(fh.read(), globalz, localz)

Se você realmente precisava ...

Se o script que você deseja carregar estiver no mesmo diretório que o que você executa, talvez "importar" faça o trabalho?

Se você precisar importar código dinamicamente, vale a pena examinar a função interna __ import__ e o módulo imp .

>>> import sys
>>> sys.path = ['/path/to/script'] + sys.path
>>> __import__('test')
<module 'test' from '/path/to/script/test.pyc'>
>>> __import__('test').run()
'Hello world!'

test.py:

def run():
        return "Hello world!"

Se você estiver usando o Python 3.1 ou posterior, verifique também o importlib .

Aqui está o que eu tinha ( filejá está atribuído ao caminho do arquivo com o código fonte nos dois exemplos):

execfile(file)

Aqui está o que eu substituí por:

exec(compile(open(file).read(), file, 'exec'))

Minha parte favorita: a segunda versão funciona muito bem no Python 2 e 3, o que significa que não é necessário adicionar uma lógica dependente da versão.

Observe que o padrão acima falhará se você estiver usando declarações de codificação PEP-263 que não são ascii ou utf-8. Você precisa encontrar a codificação dos dados e codificá-los corretamente antes de entregá-los a exec ().

class python3Execfile(object):
    def _get_file_encoding(self, filename):
        with open(filename, 'rb') as fp:
            try:
                return tokenize.detect_encoding(fp.readline)[0]
            except SyntaxError:
                return "utf-8"

    def my_execfile(filename):
        globals['__file__'] = filename
        with open(filename, 'r', encoding=self._get_file_encoding(filename)) as fp:
            contents = fp.read()
        if not contents.endswith("\n"):
            # http://bugs.python.org/issue10204
            contents += "\n"
        exec(contents, globals, globals)

Além disso, embora não seja uma solução Python pura, se você estiver usando IPython (como provavelmente deveria), você pode:

%run /path/to/filename.py

O que é igualmente fácil.

Eu sou apenas um novato aqui, então talvez seja pura sorte se eu encontrar isso:

Depois de tentar executar um script no prompt do intérprete >>> com o comando

    execfile('filename.py')

para o qual eu recebi um "NameError: name 'execfile' não está definido", tentei um método muito básico

    import filename

funcionou bem :-)

Espero que isso possa ser útil e obrigado a todos pelas ótimas dicas, exemplos e todos os trechos de código comentados por especialistas que são uma ótima inspiração para os novatos!

Eu uso o Ubuntu 16.014 LTS x64. Python 3.5.2 (padrão, 17 de novembro de 2016, 17:05:23) [GCC 5.4.0 20160609] no linux

Para mim, a abordagem mais limpa é usar importlibe importar o arquivo como módulo por caminho, assim:

from importlib import util

def load_file(name, path):
    spec = util.spec_from_file_location(name, path)
    module = util.module_from_spec(spec)
    spec.loader.exec_module(module)
    return module

Exemplo de uso

Vamos ter um arquivo foo.py:

print('i got imported')
def hello():
    print('hello from foo')

Agora basta importar e usá-lo como um módulo normal:

>>> foo = load_file('foo', './foo.py')
i got imported
>>> foo.hello()
hello from foo

Eu prefiro essa técnica a abordagens diretas, como exec(open(...))porque ela não bagunça seus espaços de nome ou mexe desnecessariamente $PATH.