Wie entlade ich ein Modul (lade es neu)?

Ich habe einen lang laufenden Python-Server und möchte einen Dienst aktualisieren können, ohne den Server neu zu starten. Was ist der beste Weg, dies zu tun?

if foo.py has changed:
    unimport foo  <-- How do I do this?
    import foo
    myfoo = foo.Foo()

Sie können ein Modul neu laden, wenn es bereits importiert wurde, indem Sie die reloadintegrierte Funktion verwenden (nur Python 3.4+) :

from importlib import reload  
import foo

while True:
    # Do some things.
    if is_changed(foo):
        foo = reload(foo)

In Python 3 reloadwurde in das impModul verschoben . In 3.4 impwurde zugunsten von abgelehnt importlibund reloadzu letzterem hinzugefügt. Wenn Sie auf 3 oder höher abzielen, verweisen Sie beim Aufrufen entweder auf das entsprechende Modul reloadoder importieren Sie es.

Ich denke, das ist was du willst. Webserver wie der Entwicklungsserver von Django verwenden dies, damit Sie die Auswirkungen Ihrer Codeänderungen sehen können, ohne den Serverprozess selbst neu zu starten.

Um aus den Dokumenten zu zitieren:

Der Code der Python-Module wird neu kompiliert und der Code auf Modulebene erneut ausgeführt, wodurch eine neue Gruppe von Objekten definiert wird, die an Namen im Wörterbuch des Moduls gebunden sind. Die Init-Funktion von Erweiterungsmodulen wird nicht ein zweites Mal aufgerufen. Wie bei allen anderen Objekten in Python werden die alten Objekte erst zurückgefordert, nachdem ihre Referenzanzahl auf Null gefallen ist. Die Namen im Modul-Namespace werden aktualisiert, um auf neue oder geänderte Objekte zu verweisen. Andere Verweise auf die alten Objekte (z. B. Namen außerhalb des Moduls) werden nicht zurückgebunden, um auf die neuen Objekte zu verweisen, und müssen in jedem Namespace aktualisiert werden, in dem sie auftreten, wenn dies gewünscht wird.

Wie Sie in Ihrer Frage festgestellt haben, müssen Sie FooObjekte rekonstruieren , wenn sich die FooKlasse im fooModul befindet.

In Python 3.0–3.3 würden Sie Folgendes verwenden: imp.reload(module)

Die BDFL hat geantwortet diese Frage .

Allerdings impwurde in 3.4 zugunsten vonimportlib (danke @Stefan! ) Veraltet .

Ich denke , deshalb würden Sie jetzt verwenden importlib.reload(module), obwohl ich nicht sicher bin.

Es kann besonders schwierig sein, ein Modul zu löschen, wenn es nicht reines Python ist.

Hier einige Informationen von: Wie lösche ich ein importiertes Modul wirklich?

Mit sys.getrefcount () können Sie die tatsächliche Anzahl der Referenzen ermitteln.

>>> import sys, empty, os
>>> sys.getrefcount(sys)
9
>>> sys.getrefcount(os)
6
>>> sys.getrefcount(empty)
3

Zahlen größer als 3 zeigen an, dass es schwierig sein wird, das Modul loszuwerden. Das selbstgezogene "leere" (nichts enthaltende) Modul sollte nach dem Sammeln von Müll gesammelt werden

>>> del sys.modules["empty"]
>>> del empty

als dritte Referenz ist ein Artefakt der Funktion getrefcount ().

reload(module), aber nur, wenn es völlig eigenständig ist. Wenn irgendetwas anderes einen Verweis auf das Modul (oder ein zum Modul gehörendes Objekt) enthält, werden subtile und merkwürdige Fehler angezeigt, die dadurch verursacht werden, dass der alte Code länger als erwartet herumhängt und Dinge wie das isinstanceNicht-Arbeiten in verschiedenen Versionen des Moduls gleicher Code.

Wenn Sie Einwegabhängigkeiten haben, müssen Sie auch alle Module neu laden, die vom neu geladenen Modul abhängen, um alle Verweise auf den alten Code zu entfernen. Laden Sie dann die Module, die von den neu geladenen Modulen abhängen, rekursiv neu.

Wenn Sie zirkuläre Abhängigkeiten haben, was beispielsweise beim erneuten Laden eines Pakets sehr häufig vorkommt, müssen Sie alle Module in der Gruppe auf einmal entladen. Das kann man nicht machenreload() da jedes Modul erneut importiert wird, bevor seine Abhängigkeiten aktualisiert wurden, sodass sich alte Referenzen in neue Module einschleichen können.

Die einzige Möglichkeit, dies in diesem Fall zu tun, ist das Hacken sys.modules, was nicht unterstützt wird. Sie sys.modulesmüssten jeden Eintrag löschen, den Sie beim nächsten Import neu laden möchten, und auch Einträge löschen, deren Werte sindNone ein Implementierungsproblem im Zusammenhang mit dem Zwischenspeichern fehlgeschlagener relativer Importe behandeln sollen. Es ist nicht besonders schön, aber solange Sie eine vollständig in sich geschlossene Reihe von Abhängigkeiten haben, die keine Referenzen außerhalb der Codebasis belassen, ist es funktionsfähig.

Es ist wahrscheinlich am besten, den Server neu zu starten. :-)

if 'myModule' in sys.modules:  
    del sys.modules["myModule"]

Verwenden Sie für Python 2 die integrierte Funktion reload () :

reload(module)

Verwenden Sie für Python 2 und 3.2–3.3 reload from module imp :

import imp
imp.reload(module)

Aber imp ist veraltet , da Version 3.4 für importlib , so verwenden:

import importlib
importlib.reload(module)

oder

from importlib import reload
reload(module)

Mit dem folgenden Code können Sie Python 2/3 kompatibel machen:

try:
    reload
except NameError:
    # Python 3
    from imp import reload

Sie können es wie reload()in beiden Versionen verwenden, was die Sache einfacher macht.

Die akzeptierte Antwort behandelt den Fall von X-Import Y nicht. Dieser Code behandelt es und den Standardimportfall auch:

def importOrReload(module_name, *names):
    import sys

    if module_name in sys.modules:
        reload(sys.modules[module_name])
    else:
        __import__(module_name, fromlist=names)

    for name in names:
        globals()[name] = getattr(sys.modules[module_name], name)

# use instead of: from dfly_parser import parseMessages
importOrReload("dfly_parser", "parseMessages")

Im Fall des erneuten Ladens weisen wir die Namen der obersten Ebene den Werten zu, die im neu geladenen Modul gespeichert sind, wodurch sie aktualisiert werden.

Dies ist die moderne Art, ein Modul neu zu laden:

from importlib import reload

Wenn Sie Versionen von Python unterstützen möchten, die älter als 3.5 sind, versuchen Sie Folgendes:

from sys import version_info
if version_info[0] < 3:
    pass # Python 2 has built in reload
elif version_info[0] == 3 and version_info[1] <= 4:
    from imp import reload # Python 3.0 - 3.4 
else:
    from importlib import reload # Python 3.5+

Um es zu verwenden, führen Sie es aus reload(MODULE)und ersetzen Sie esMODULE durch das Modul, das Sie neu laden möchten.

Zum Beispiel reload(math)wird das mathModul neu geladen .

Wenn Sie sich nicht auf einem Server befinden, aber ein Modul entwickeln und häufig neu laden müssen, finden Sie hier einen guten Tipp.

Stellen Sie zunächst sicher, dass Sie die hervorragende IPython-Shell aus dem Jupyter Notebook-Projekt verwenden. Nach der Installation von Jupyter können Sie mit ipythonoder jupyter consoleoder noch besser beginnen.jupyter qtconsole , wodurch Sie eine schöne farbige Konsole mit Code-Vervollständigung in jedem Betriebssystem erhalten.

Geben Sie nun in Ihrer Shell Folgendes ein:

%load_ext autoreload
%autoreload 2

Jetzt jedes Mal Sie Ihr Skript ausführen, werden Ihre Module neu geladen.

Darüber hinaus 2gibt es andere Optionen der Autoreload-Magie :

%autoreload
Reload all modules (except those excluded by %aimport) automatically now.

%autoreload 0
Disable automatic reloading.

%autoreload 1
Reload all modules imported with %aimport every time before executing the Python code typed.

%autoreload 2
Reload all modules (except those excluded by %aimport) every time before
executing the Python code typed.

Für diejenigen wie mich, die alle Module entladen möchten (wenn sie im Python-Interpreter unter Emacs ausgeführt werden ):

   for mod in sys.modules.values():
      reload(mod)

Weitere Informationen finden Sie unter Reloading Python-Module .

Enthought Traits hat ein Modul, das dafür ziemlich gut funktioniert. https://traits.readthedocs.org/en/4.3.0/_modules/traits/util/refresh.html

Es wird jedes Modul, das geändert wurde, neu laden und andere Module und instanziierte Objekte aktualisieren, die es verwenden. Es funktioniert die meiste Zeit nicht mit __very_private__Methoden und kann an der Klassenvererbung ersticken, aber es erspart mir verrückte Zeit, die Host-Anwendung beim Schreiben von PyQt-Guis neu starten zu müssen, oder Dinge, die in Programmen wie Maya oder Nuke ausgeführt werden. Es funktioniert vielleicht 20-30% der Zeit nicht, aber es ist immer noch unglaublich hilfreich.

Das Paket von Enthought lädt Dateien nicht neu, sobald sie sich ändern - Sie müssen es explizit aufrufen -, aber das sollte nicht allzu schwer zu implementieren sein, wenn Sie es wirklich brauchen

Diejenigen, die Python 3 verwenden und von importlib neu laden.

Wenn Sie Probleme haben, wie es scheint, dass das Modul nicht neu geladen wird ... Das liegt daran, dass es einige Zeit braucht, um pyc neu zu kompilieren (bis zu 60 Sekunden). Ich schreibe diesen Hinweis nur, damit Sie wissen, ob Sie diese Art von Problem haben.

2018-02-01

1. Modul foomuss im Voraus erfolgreich importiert werden.
2. from importlib import reload, reload(foo)

31.5. importlib - Die Implementierung der Dokumentation zu import - Python 3.6.4

Andere Option. Beachten Sie, dass Python standardmäßig importlib.reloaddie als Argument übergebene Bibliothek nur erneut importiert. Die von Ihrer Bibliothek importierten Bibliotheken werden nicht neu geladen. Wenn Sie viele Dateien geändert haben und ein etwas komplexes Paket importieren müssen, müssen Sie ein tiefes Neuladen durchführen .

Wenn Sie IPython oder Jupyter installiert haben, können Sie eine Funktion verwenden, um alle Bibliotheken tief zu laden:

from IPython.lib.deepreload import reload as dreload
dreload(foo)

Wenn Sie Jupyter nicht haben, installieren Sie es mit diesem Befehl in Ihrer Shell:

pip3 install jupyter

Bearbeiten (Antwort V2)

Die vorherige Lösung eignet sich nur zum Abrufen der Rücksetzinformationen, ändert jedoch nicht alle Referenzen (mehr als, reloadaber weniger als erforderlich). Um auch alle Referenzen zu setzen, musste ich in den Garbage Collector gehen und die Referenzen dort neu schreiben. Jetzt funktioniert es wie ein Zauber!

Beachten Sie, dass dies nicht funktioniert, wenn der GC ausgeschaltet ist oder wenn Daten neu geladen werden, die nicht vom GC überwacht werden. Wenn Sie sich nicht mit dem GC anlegen möchten, reicht Ihnen möglicherweise die ursprüngliche Antwort.

Neuer Code:

import importlib
import inspect
import gc
from weakref import ref


def reset_module(module, inner_modules_also=True):
    """
    This function is a stronger form of importlib's `reload` function. What it does, is that aside from reloading a
    module, it goes to the old instance of the module, and sets all the (not read-only) attributes, functions and classes
    to be the reloaded-module's
    :param module: The module to reload (module reference, not the name)
    :param inner_modules_also: Whether to treat ths module as a package as well, and reload all the modules within it.
    """

    # For the case when the module is actually a package
    if inner_modules_also:
        submods = {submod for _, submod in inspect.getmembers(module)
                   if (type(submod).__name__ == 'module') and (submod.__package__.startswith(module.__name__))}
        for submod in submods:
            reset_module(submod, True)

    # First, log all the references before reloading (because some references may be changed by the reload operation).
    module_tree = _get_tree_references_to_reset_recursively(module, module.__name__)

    new_module = importlib.reload(module)
    _reset_item_recursively(module, module_tree, new_module)


def _update_referrers(item, new_item):
    refs = gc.get_referrers(item)

    weak_ref_item = ref(item)
    for coll in refs:
        if type(coll) == dict:
            enumerator = coll.keys()
        elif type(coll) == list:
            enumerator = range(len(coll))
        else:
            continue

        for key in enumerator:

            if weak_ref_item() is None:
                # No refs are left in the GC
                return

            if coll[key] is weak_ref_item():
                coll[key] = new_item

def _get_tree_references_to_reset_recursively(item, module_name, grayed_out_item_ids = None):
    if grayed_out_item_ids is None:
        grayed_out_item_ids = set()

    item_tree = dict()
    attr_names = set(dir(item)) - _readonly_attrs
    for sub_item_name in attr_names:

        sub_item = getattr(item, sub_item_name)
        item_tree[sub_item_name] = [sub_item, None]

        try:
            # Will work for classes and functions defined in that module.
            mod_name = sub_item.__module__
        except AttributeError:
            mod_name = None

        # If this item was defined within this module, deep-reset
        if (mod_name is None) or (mod_name != module_name) or (id(sub_item) in grayed_out_item_ids) \
                or isinstance(sub_item, EnumMeta):
            continue

        grayed_out_item_ids.add(id(sub_item))
        item_tree[sub_item_name][1] = \
            _get_tree_references_to_reset_recursively(sub_item, module_name, grayed_out_item_ids)

    return item_tree


def _reset_item_recursively(item, item_subtree, new_item):

    # Set children first so we don't lose the current references.
    if item_subtree is not None:
        for sub_item_name, (sub_item, sub_item_tree) in item_subtree.items():

            try:
                new_sub_item = getattr(new_item, sub_item_name)
            except AttributeError:
                # The item doesn't exist in the reloaded module. Ignore.
                continue

            try:
                # Set the item
                _reset_item_recursively(sub_item, sub_item_tree, new_sub_item)
            except Exception as ex:
                pass

    _update_referrers(item, new_item)

Ursprüngliche Antwort

Wie in der Antwort von @ bobince geschrieben , wird diese Instanz nicht überschrieben , wenn in einem anderen Modul bereits ein Verweis auf dieses Modul vorhanden ist (insbesondere wenn es mit dem asSchlüsselwort like importiert wurde import numpy as np).

Dies erwies sich für mich als ziemlich problematisch, wenn ich Tests anwendete, die einen "Clean-Slate" -Status der Konfigurationsmodule erforderten. Daher habe ich eine Funktion mit dem Namen geschrieben reset_module, die importlibdie reloadFunktion verwendet und alle Attribute des deklarierten Moduls rekursiv überschreibt. Es wurde mit Python Version 3.6 getestet.

import importlib
import inspect
from enum import EnumMeta

_readonly_attrs = {'__annotations__', '__call__', '__class__', '__closure__', '__code__', '__defaults__', '__delattr__',
               '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__func__', '__ge__', '__get__',
               '__getattribute__', '__globals__', '__gt__', '__hash__', '__init__', '__init_subclass__',
               '__kwdefaults__', '__le__', '__lt__', '__module__', '__name__', '__ne__', '__new__', '__qualname__',
               '__reduce__', '__reduce_ex__', '__repr__', '__self__', '__setattr__', '__sizeof__', '__str__',
               '__subclasshook__', '__weakref__', '__members__', '__mro__', '__itemsize__', '__isabstractmethod__',
               '__basicsize__', '__base__'}


def reset_module(module, inner_modules_also=True):
    """
    This function is a stronger form of importlib's `reload` function. What it does, is that aside from reloading a
    module, it goes to the old instance of the module, and sets all the (not read-only) attributes, functions and classes
    to be the reloaded-module's
    :param module: The module to reload (module reference, not the name)
    :param inner_modules_also: Whether to treat ths module as a package as well, and reload all the modules within it.
    """

    new_module = importlib.reload(module)

    reset_items = set()

    # For the case when the module is actually a package
    if inner_modules_also:
        submods = {submod for _, submod in inspect.getmembers(module)
                   if (type(submod).__name__ == 'module') and (submod.__package__.startswith(module.__name__))}
        for submod in submods:
            reset_module(submod, True)

    _reset_item_recursively(module, new_module, module.__name__, reset_items)


def _reset_item_recursively(item, new_item, module_name, reset_items=None):
    if reset_items is None:
        reset_items = set()

    attr_names = set(dir(item)) - _readonly_attrs

    for sitem_name in attr_names:

        sitem = getattr(item, sitem_name)
        new_sitem = getattr(new_item, sitem_name)

        try:
            # Set the item
            setattr(item, sitem_name, new_sitem)

            try:
                # Will work for classes and functions defined in that module.
                mod_name = sitem.__module__
            except AttributeError:
                mod_name = None

            # If this item was defined within this module, deep-reset
            if (mod_name is None) or (mod_name != module_name) or (id(sitem) in reset_items) \
                    or isinstance(sitem, EnumMeta):  # Deal with enums
                continue

            reset_items.add(id(sitem))
            _reset_item_recursively(sitem, new_sitem, module_name, reset_items)
        except Exception as ex:
            raise Exception(sitem_name) from ex

Hinweis: Vorsichtig verwenden! Die Verwendung dieser Module für nicht periphere Module (Module, die beispielsweise extern verwendete Klassen definieren) kann zu internen Problemen in Python führen (z. B. Probleme beim Beizen / Entbeizen).

Für mich im Fall von Abaqus ist es die Art und Weise, wie es funktioniert. Stellen Sie sich vor, Ihre Datei ist Class_VerticesEdges.py

sys.path.append('D:\...\My Pythons')
if 'Class_VerticesEdges' in sys.modules:  
    del sys.modules['Class_VerticesEdges']
    print 'old module Class_VerticesEdges deleted'
from Class_VerticesEdges import *
reload(sys.modules['Class_VerticesEdges'])

Ich hatte große Probleme beim Versuch, etwas in Sublime Text neu zu laden, aber schließlich konnte ich dieses Dienstprogramm schreiben, um Module in Sublime Text basierend auf dem Code neu zu laden sublime_plugin.py der zum Neuladen von Modulen verwendet wird.

Im Folgenden können Sie Module aus Pfaden mit Leerzeichen auf ihren Namen neu laden. Später nach dem Neuladen können Sie sie einfach wie gewohnt importieren.

def reload_module(full_module_name):
    """
        Assuming the folder `full_module_name` is a folder inside some
        folder on the python sys.path, for example, sys.path as `C:/`, and
        you are inside the folder `C:/Path With Spaces` on the file 
        `C:/Path With Spaces/main.py` and want to re-import some files on
        the folder `C:/Path With Spaces/tests`

        @param full_module_name   the relative full path to the module file
                                  you want to reload from a folder on the
                                  python `sys.path`
    """
    import imp
    import sys
    import importlib

    if full_module_name in sys.modules:
        module_object = sys.modules[full_module_name]
        module_object = imp.reload( module_object )

    else:
        importlib.import_module( full_module_name )

def run_tests():
    print( "\n\n" )
    reload_module( "Path With Spaces.tests.semantic_linefeed_unit_tests" )
    reload_module( "Path With Spaces.tests.semantic_linefeed_manual_tests" )

    from .tests import semantic_linefeed_unit_tests
    from .tests import semantic_linefeed_manual_tests

    semantic_linefeed_unit_tests.run_unit_tests()
    semantic_linefeed_manual_tests.run_manual_tests()

if __name__ == "__main__":
    run_tests()

Wenn Sie zum ersten Mal ausführen, sollte das Modul geladen werden. Wenn Sie jedoch später die Methode / Funktion erneut verwenden run_tests()können, werden die Testdateien neu geladen . Bei Sublime Text ( Python 3.3.6) passiert dies häufig, da der Interpreter nie geschlossen wird (es sei denn, Sie starten Sublime Text, dh den Python3.3Interpreter, neu).

Eine andere Möglichkeit könnte darin bestehen, das Modul in eine Funktion zu importieren. Auf diese Weise wird nach Abschluss der Funktion des Moduls Müll gesammelt.