Python 2 had the builtin function execfile, which was removed in Python 3.0. This question discusses alternatives for Python 3.0, but some considerable changes have been made since Python 3.0.
What is the best alternative to execfile for Python 3.2, and future Python 3.x versions?
The 2to3 script replaces
execfile(filename, globals, locals)
by
exec(compile(open(filename, "rb").read(), filename, 'exec'), globals, locals)
This seems to be the official recommendation. You may want to use a with block to ensure that the file is promptly closed again:
with open(filename, "rb") as source_file:
code = compile(source_file.read(), filename, "exec")
exec(code, globals, locals)
You can omit the globals and locals arguments to execute the file in the current scope, or use exec(code, {}) to use a new temporary dictionary as both the globals and locals dictionary, effectively executing the file in a new temporary scope.
globals and locals parameters, it will also work in all versions of Python. –
Terrarium execfile() in Python 3.x. You are using Python 2.7, so all this isn't relevant for you. I explained in this comment what your actual problem is. –
Terrarium compile() figure out the right encoding should fix this -- I updated the answer accordingly. –
Terrarium bytes are not listed among accepted inputs for compile(). –
Upbow compile() does actually accept bytes, and it respects any encoding specification in the source code to decode it to a string, so I think it's the most robust way to do this. –
Terrarium compile() on a bytes object: hg.python.org/cpython/file/9bce03920afe/Lib/importlib/… –
Terrarium TypeError: exec() arg 2 must be a dict, not builtin_function_or_method –
Pullen locals and globals with whatever you want to have there instead. They are just placeholders, I can't know what you want to pass in, or whether you want to omit them altogether. I consider this the "official" recommendation because this is how the "official" 2to3 tool migrates execfile() calls. –
Terrarium exec(..., {}) to execute the file in a new temporary scope. –
Terrarium globals() and locals() be executed functions? –
Husch globals and locals as variable names here; I could just as well have used x and y or whatever. You usually wouldn't do exec(code, globals(), locals()), since this would be the same as just exec(code). –
Terrarium execfile(filename)
can be replaced with
exec(open(filename).read())
which works in all versions of Python
Newer versions of Python will warn you that you didn't close that file, so then you can do this is you want to get rid of that warning:
with open(filename) as infile:
exec(infile.read())
But really, if you care about closing files, you should care enough to not use exec in the first place.
exec ... in ... form of exec in such a situation. For example exec code in globals() will execute the code in the module's global namespace. Note that the exec'ed code can't change local variables in a way that is reliably visible by the nested function. –
Terrarium In Python3.x this is the closest thing I could come up with to executing a file directly, that matches running python /path/to/somefile.py.
Notes:
__main__, some scripts depend on this to check if they are loading as a module or not for eg. if __name__ == "__main__"__file__ is nicer for exception messages and some scripts use __file__ to get the paths of other files relative to them.def exec_full(filepath):
global_namespace = {
"__file__": filepath,
"__name__": "__main__",
}
with open(filepath, 'rb') as file:
exec(compile(file.read(), filepath, 'exec'), global_namespace)
# Execute the file.
exec_full("/path/to/somefile.py")
exec_full –
Peabody © 2022 - 2024 — McMap. All rights reserved.