Was ist eine Alternative zu Execfile in Python 3?

Es scheint, dass sie in Python 3 auf einfache Weise abgebrochen wurden, um ein Skript durch Entfernen schnell zu laden execfile()

Gibt es eine offensichtliche Alternative, die mir fehlt?

Laut Dokumentation statt

execfile("./filename") 

Verwenden

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

Sehen:

• Was ist neu in Python 3.0?

Sie müssen nur die Datei lesen und den Code selbst ausführen. 2to3 Strom ersetzt

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

wie

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

(Der Kompilierungsaufruf wird nicht unbedingt benötigt, ordnet jedoch den Dateinamen dem Codeobjekt zu, was das Debuggen etwas erleichtert.)

Sehen:

• 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

Obwohl exec(open("filename").read())es oft als Alternative zu gegeben wird execfile("filename"), fehlen wichtige Details, die execfileunterstützt werden.

Die folgende Funktion für Python3.x ist so nah wie möglich am gleichen Verhalten wie das direkte Ausführen einer Datei. Das passt zum Laufen 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")

Anmerkungen:

• Verwendet binäres Lesen, um Codierungsprobleme zu vermeiden
• Garantiert das Schließen der Datei (Python3.x warnt davor)
• Definiert __main__, einige Skripte hängen davon ab, um zu überprüfen, ob sie als Modul geladen werden oder nicht, z.if __name__ == "__main__"
• Die Einstellung __file__ist für Ausnahmemeldungen __file__besser und einige Skripte verwenden , um die Pfade anderer Dateien relativ zu ihnen abzurufen.

• Nimmt optionale globale und lokale Argumente auf und execfileändert sie an Ort und Stelle. So können Sie auf alle Variablen zugreifen, die durch Zurücklesen der Variablen nach dem Ausführen definiert wurden.

• Im Gegensatz zu Python2 execfileändert dies standardmäßig nicht den aktuellen Namespace. Dafür müssen Sie globals()& explizit übergeben locals().

Wie kürzlich auf der Python-Dev- Mailingliste vorgeschlagen, ist das Runpy- Modul möglicherweise eine praktikable Alternative. Zitat aus dieser Nachricht:

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

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

Es gibt subtile Unterschiede zu execfile:

• run_pathErstellt immer einen neuen Namespace. Es führt den Code als Modul aus, sodass es keinen Unterschied zwischen globalen und lokalen Elementen gibt (weshalb es nur ein init_globalsArgument gibt). Die Globals werden zurückgegeben.

  execfileim aktuellen Namespace oder im angegebenen Namespace ausgeführt. Die Semantik von localsund globals, falls angegeben, ähnelte den Einheimischen und Globalen innerhalb einer Klassendefinition.

• run_path kann nicht nur Dateien, sondern auch Eier und Verzeichnisse ausführen (Einzelheiten finden Sie in der Dokumentation).

Dieser ist besser, da er die Anrufer und Einheimischen vom Anrufer nimmt:

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)

Sie könnten Ihre eigene Funktion schreiben:

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

Wenn Sie wirklich ...

Wenn sich das Skript, das Sie laden möchten, im selben Verzeichnis befindet wie das, das Sie ausführen, erledigt "import" möglicherweise die Aufgabe?

Wenn Sie Code dynamisch importieren müssen, sollten Sie sich die integrierte Funktion __ import__ und das Modul imp ansehen .

>>> 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!"

Wenn Sie Python 3.1 oder höher verwenden, sollten Sie auch einen Blick darauf werfen importlib ansehen .

Folgendes hatte ich ( fileist in beiden Beispielen bereits dem Pfad zur Datei mit dem Quellcode zugeordnet):

execfile(file)

Folgendes habe ich ersetzt:

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

Mein Lieblingsteil: Die zweite Version funktioniert sowohl in Python 2 als auch in Python 3 einwandfrei, was bedeutet, dass es nicht erforderlich ist, eine versionabhängige Logik hinzuzufügen.

Beachten Sie, dass das obige Muster fehlschlägt, wenn Sie PEP-263-Codierungsdeklarationen verwenden, die nicht ASCII oder UtF-8 sind. Sie müssen die Codierung der Daten finden und korrekt codieren, bevor Sie sie an exec () übergeben.

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)

Auch wenn Sie keine reine Python-Lösung sind, können Sie mit IPython (wie Sie es wahrscheinlich sowieso tun sollten) Folgendes tun:

%run /path/to/filename.py

Welches ist ebenso einfach.

Ich bin nur ein Neuling hier, also ist es vielleicht reines Glück, wenn ich Folgendes gefunden habe:

Nachdem Sie versucht haben, ein Skript an der Interpreter-Eingabeaufforderung >>> mit dem Befehl auszuführen

    execfile('filename.py')

für die ich einen "NameError: Name 'execfile' ist nicht definiert" bekam, habe ich einen sehr einfachen versucht

    import filename

es hat gut funktioniert :-)

Ich hoffe, dass dies hilfreich sein kann und danke Ihnen allen für die großartigen Hinweise, Beispiele und all die meisterhaft kommentierten Codeteile, die eine großartige Inspiration für Neulinge sind!

Ich benutze Ubuntu 16.014 LTS x64. Python 3.5.2 (Standard, 17. November 2016, 17:05:23) [GCC 5.4.0 20160609] unter Linux

Für mich ist der sauberste Ansatz, importlibdie Datei als Modul nach Pfad zu verwenden und zu importieren, wie folgt:

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

Anwendungsbeispiel

Lassen Sie uns eine Datei haben foo.py:

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

Jetzt einfach importieren und wie ein normales Modul verwenden:

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

Ich bevorzuge diese Technik gegenüber direkten Ansätzen, exec(open(...))weil sie Ihre Namespaces nicht überladen oder unnötig durcheinander bringt $PATH.