Qual è un'alternativa a execfile in Python 3?

Sembra che abbiano cancellato in Python 3 tutto il modo semplice per caricare rapidamente uno script rimuovendolo execfile()

C'è un'alternativa ovvia che mi manca?

Secondo la documentazione , invece di

execfile("./filename") 

Uso

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

Vedere:

• Novità di Python 3.0

Devi solo leggere il file ed eseguire il codice da solo. 2to3 sostituisce corrente

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

come

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

(La chiamata di compilazione non è strettamente necessaria, ma associa il nome file all'oggetto codice rendendo il debug un po 'più semplice.)

Vedere:

• 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

Mentre exec(open("filename").read())viene spesso fornito in alternativa a execfile("filename"), manca dettagli importanti che execfilesupportano.

La seguente funzione per Python3.x è la più vicina possibile allo stesso comportamento dell'esecuzione diretta di un file. Questo corrisponde alla corsa 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")

Appunti:

• Utilizza la lettura binaria per evitare problemi di codifica
• Garantito per chiudere il file (Python3.x avverte di questo)
• Definisce __main__, alcuni script dipendono da questo per verificare se si stanno caricando come modulo o no per es.if __name__ == "__main__"
• L'impostazione __file__è migliore per i messaggi di eccezione e alcuni script utilizzano __file__per ottenere i percorsi di altri file relativi ad essi.

• Accetta argomenti globali e locali opzionali, modificandoli sul posto come execfilefa, in modo da poter accedere a qualsiasi variabile definita leggendo le variabili dopo l'esecuzione.

• A differenza di Python2, execfilequesto non modifica lo spazio dei nomi corrente per impostazione predefinita. Per questo devi esplicitamente passare globals()& locals().

Come suggerito recentemente sulla mailing list di python-dev , il modulo runpy potrebbe essere una valida alternativa. Citando da quel messaggio:

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

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

Ci sono sottili differenze rispetto a execfile:

• run_pathcrea sempre un nuovo spazio dei nomi. Esegue il codice come modulo, quindi non c'è differenza tra globali e locali (motivo per cui esiste solo un init_globalsargomento). I globi vengono restituiti.

  execfileeseguito nello spazio dei nomi corrente o nello spazio dei nomi indicato. La semantica di localse globals, se data, erano simili a locali e globali all'interno di una definizione di classe.

• run_path può non solo eseguire file, ma anche uova e directory (fare riferimento alla sua documentazione per i dettagli).

Questo è meglio, dal momento che prende i globali e i locali dal chiamante:

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)

Puoi scrivere la tua funzione:

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

Se hai davvero bisogno di ...

Se lo script che vuoi caricare si trova nella stessa directory di quella che esegui, forse "import" farà il lavoro?

Se devi importare dinamicamente il codice, vale la pena guardare la funzione integrata __ import__ e il modulo 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 stai usando Python 3.1 o versioni successive, dovresti anche dare un'occhiata a importlib .

Ecco cosa avevo ( fileè già assegnato al percorso del file con il codice sorgente in entrambi gli esempi):

execfile(file)

Ecco cosa l'ho sostituito con:

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

La mia parte preferita: la seconda versione funziona perfettamente in Python 2 e 3, il che significa che non è necessario aggiungere una logica dipendente dalla versione.

Si noti che il modello precedente non funzionerà se si utilizzano dichiarazioni di codifica PEP-263 che non sono ASCII o UTF-8. Devi trovare la codifica dei dati e codificarla correttamente prima di consegnarla 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)

Inoltre, pur non essendo una soluzione Python pura, se stai usando IPython (come probabilmente dovresti comunque), puoi fare:

%run /path/to/filename.py

È altrettanto facile.

Sono solo un principiante qui, quindi forse è pura fortuna se ho trovato questo:

Dopo aver provato a eseguire uno script dal prompt dell'interprete >>> con il comando

    execfile('filename.py')

per cui ho ottenuto un "NameError: il nome 'execfile' non è definito" Ho provato un metodo molto semplice

    import filename

ha funzionato bene :-)

Spero che questo possa essere utile e grazie a tutti per i grandi suggerimenti, esempi e tutti quei pezzi di codice commentati magistralmente che sono di grande ispirazione per i nuovi arrivati!

Uso Ubuntu 16.014 LTS x64. Python 3.5.2 (impostazione predefinita, 17 novembre 2016, 17:05:23) [GCC 5.4.0 20160609] su Linux

Per me, l'approccio più pulito è quello di utilizzare importlibe importare il file come modulo per percorso, in questo modo:

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

Esempio di utilizzo

Diamo un file foo.py:

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

Ora importalo e usalo come un normale modulo:

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

Preferisco questa tecnica rispetto ad approcci diretti come exec(open(...))perché non ingombrano i tuoi spazi dei nomi o rovinano inutilmente $PATH.