¿Qué es una alternativa a execfile en Python 3?

Parece que cancelaron en Python 3 toda la manera fácil de cargar rápidamente un script eliminando execfile()

¿Hay una alternativa obvia que me falta?

Según la documentación , en lugar de

execfile("./filename") 

Utilizar

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

Ver:

• ¿Qué hay de nuevo en Python 3.0?

Se supone que solo debes leer el archivo y ejecutar el código tú mismo. La corriente 2to3 reemplaza

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)

(La llamada de compilación no es estrictamente necesaria, pero asocia el nombre de archivo con el objeto de código, lo que facilita un poco la depuración).

Ver:

• 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

Si bien a exec(open("filename").read())menudo se ofrece como una alternativa execfile("filename"), se pierden detalles importantes que execfilerespaldan.

La siguiente función para Python3.x es lo más cercana posible a tener el mismo comportamiento que ejecutar un archivo directamente. Eso coincide con 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:

• Utiliza lectura binaria para evitar problemas de codificación
• Garantizado para cerrar el archivo (Python3.x advierte sobre esto)
• Define __main__, algunos scripts dependen de esto para verificar si se están cargando como un módulo o no, por ejemplo.if __name__ == "__main__"
• La configuración __file__es mejor para los mensajes de excepción y algunas secuencias de comandos se utilizan __file__para obtener las rutas de otros archivos en relación con ellos.

• Toma argumentos opcionales globales y locales, modificándolos en el lugar como lo execfilehace, para que pueda acceder a cualquier variable definida al leer las variables después de la ejecución.

• A diferencia de Python2, execfileesto no modifica el espacio de nombres actual de forma predeterminada. Para eso tienes que pasar explícitamente globals()& locals().

Como se sugirió recientemente en la lista de correo python-dev , el módulo runpy podría ser una alternativa viable. Citando de ese mensaje:

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

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

Hay diferencias sutiles para execfile:

• run_pathsiempre crea un nuevo espacio de nombres. Ejecuta el código como un módulo, por lo que no hay diferencia entre globales y locales (razón por la cual solo hay un init_globalsargumento). Los globales son devueltos.

  execfileejecutado en el espacio de nombres actual o en el espacio de nombres dado. La semántica de localsy globals, si se da, eran similares a los locales y globales dentro de una definición de clase.

• run_path no solo puede ejecutar archivos, sino también huevos y directorios (consulte su documentación para más detalles).

Este es mejor, ya que toma los globales y locales de la persona que llama:

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)

Podrías escribir tu propia función:

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

Si realmente necesitaras ...

Si el script que desea cargar está en el mismo directorio que el que ejecuta, ¿tal vez "import" hará el trabajo?

Si necesita importar código dinámicamente, vale la pena mirar la función incorporada __ import__ y el 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!"

Si está utilizando Python 3.1 o posterior, también debería echar un vistazo a importlib .

Esto es lo que tenía ( fileya está asignado a la ruta del archivo con el código fuente en ambos ejemplos):

execfile(file)

Esto es con lo que lo reemplacé:

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

Mi parte favorita: la segunda versión funciona bien tanto en Python 2 como en 3, lo que significa que no es necesario agregar lógica dependiente de la versión.

Tenga en cuenta que el patrón anterior fallará si está utilizando declaraciones de codificación PEP-263 que no son ascii o utf-8. Debe encontrar la codificación de los datos y codificarla correctamente antes de entregarla 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)

Además, aunque no es una solución pura de Python, si está utilizando IPython (como probablemente debería hacerlo de todos modos), puede hacer lo siguiente:

%run /path/to/filename.py

Lo cual es igualmente fácil.

Solo soy un novato aquí, así que tal vez sea pura suerte si encuentro esto:

Después de intentar ejecutar un script desde el indicador del intérprete >>> con el comando

    execfile('filename.py')

para lo cual obtuve un "NameError: el nombre 'execfile' no está definido" Intenté un método muy básico

    import filename

funcionó bien :-)

¡Espero que esto pueda ser útil y gracias a todos por las excelentes sugerencias, ejemplos y todas esas piezas de código magistralmente comentadas que son una gran inspiración para los recién llegados!

Yo uso Ubuntu 16.014 LTS x64. Python 3.5.2 (predeterminado, 17 de noviembre de 2016, 17:05:23) [GCC 5.4.0 20160609] en Linux

Para mí, el enfoque más limpio es usar importlibe importar el archivo como un módulo por ruta, así:

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

Ejemplo de uso

Tengamos un archivo foo.py:

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

Ahora solo importe y use como un módulo normal:

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

Prefiero esta técnica sobre los enfoques directos, como exec(open(...))porque no abarrota sus espacios de nombres o se mete innecesariamente con ellos $PATH.