Können Module Eigenschaften genauso haben wie Objekte?

Mit Python-Eigenschaften kann ich es so machen, dass

obj.y 

ruft eine Funktion auf, anstatt nur einen Wert zurückzugeben.

Gibt es eine Möglichkeit, dies mit Modulen zu tun? Ich habe einen Fall, wo ich will

module.y 

eine Funktion aufrufen, anstatt nur den dort gespeicherten Wert zurückzugeben.

Nur Instanzen von Klassen neuen Stils können Eigenschaften haben. Sie können Python glauben machen, dass eine solche Instanz ein Modul ist, indem Sie sie verstecken sys.modules[thename] = theinstance. So könnte Ihre m.py-Moduldatei beispielsweise sein:

import sys

class _M(object):
    def __init__(self):
        self.c = 0
    def afunction(self):
        self.c += 1
        return self.c
    y = property(afunction)

sys.modules[__name__] = _M()

Ich würde dies tun, um alle Attribute eines Moduls richtig zu erben und durch isinstance () korrekt identifiziert zu werden.

import types

class MyModule(types.ModuleType):
    @property
    def y(self):
        return 5


>>> a=MyModule("test")
>>> a
<module 'test' (built-in)>
>>> a.y
5

Und dann können Sie dies in sys.modules einfügen:

sys.modules[__name__] = MyModule(__name__)  # remember to instantiate the class

Da PEP 562 in Python> = 3.7 implementiert wurde, können wir dies jetzt tun

Datei: module.py

def __getattr__(name):
    if name == 'y':
        return 3
    raise AttributeError(f"module '{__name__}' has no attribute '{name}'")

other = 4

Verwendung:

>>> import module
>>> module.y
3
>>> module.other
4
>>> module.nosuch
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "module.py", line 4, in __getattr__
    raise AttributeError(f"module '{__name__}' has no attribute '{name}'")
AttributeError: module 'module' has no attribute 'nosuch'

Beachten Sie, dass, wenn Sie das raise AttributeErrorin der __getattr__Funktion weglassen , dies bedeutet, dass die Funktion mit endet return Noneund das module.nosucheinen Wert von erhält None.

Basierend auf John Lins Antwort :

def module_property(func):
    """Decorator to turn module functions into properties.
    Function names must be prefixed with an underscore."""
    module = sys.modules[func.__module__]

    def base_getattr(name):
        raise AttributeError(
            f"module '{module.__name__}' has no attribute '{name}'")

    old_getattr = getattr(module, '__getattr__', base_getattr)

    def new_getattr(name):
        if f'_{name}' == func.__name__:
            return func()
        else:
            return old_getattr(name)

    module.__getattr__ = new_getattr
    return func

Verwendung (beachten Sie den führenden Unterstrich), in the_module.py:

@module_property
def _thing():
    return 'hello'

Dann:

import the_module

print(the_module.thing)  # prints 'hello'

Der führende Unterstrich ist erforderlich, um die eigenschaftsbezogene Funktion von der ursprünglichen Funktion zu unterscheiden. Ich konnte mir keine Möglichkeit vorstellen, die Kennung neu zuzuweisen, da sie während der Ausführung des Dekorateurs noch nicht zugewiesen wurde.

Beachten Sie, dass IDEs nicht wissen, dass die Eigenschaft vorhanden ist, und rote Wellen anzeigen.

Ein typischer Anwendungsfall ist: Anreichern eines (riesigen) vorhandenen Moduls mit einigen (wenigen) dynamischen Attributen - ohne das gesamte Modulmaterial in ein Klassenlayout umzuwandeln. Leider sys.modules[__name__].__class__ = MyPropertyModuleschlägt ein einfachster Modulklassen-Patch wie fehl TypeError: __class__ assignment: only for heap types. Daher muss die Modulerstellung neu verkabelt werden.

Dieser Ansatz macht es ohne Python-Import-Hooks, nur indem ein Prolog über dem Modulcode steht:

# propertymodule.py
""" Module property example """

if '__orgmod__' not in globals():

    # constant prolog for having module properties / supports reload()

    print "PropertyModule stub execution", __name__
    import sys, types
    class PropertyModule(types.ModuleType):
        def __str__(self):
            return "<PropertyModule %r from %r>" % (self.__name__, self.__file__)
    modnew = PropertyModule(__name__, __doc__)
    modnew.__modclass__ = PropertyModule        
    modnew.__file__ = __file__
    modnew.__orgmod__ = sys.modules[__name__]
    sys.modules[__name__] = modnew
    exec sys._getframe().f_code in modnew.__dict__

else:

    # normal module code (usually vast) ..

    print "regular module execution"
    a = 7

    def get_dynval(module):
        return "property function returns %s in module %r" % (a * 4, module.__name__)    
    __modclass__.dynval = property(get_dynval)

Verwendung:

>>> import propertymodule
PropertyModule stub execution propertymodule
regular module execution
>>> propertymodule.dynval
"property function returns 28 in module 'propertymodule'"
>>> reload(propertymodule)   # AFTER EDITS
regular module execution
<module 'propertymodule' from 'propertymodule.pyc'>
>>> propertymodule.dynval
"property function returns 36 in module 'propertymodule'"

Hinweis: So etwas from propertymodule import dynvalerzeugt natürlich eine eingefrorene Kopie - entsprechenddynval = someobject.dynval

Eine kurze Antwort: verwenden proxy_tools

Das proxy_toolsPaket versucht, @module_propertyFunktionen bereitzustellen .

Es wird mit installiert

pip install proxy_tools

Mit einer geringfügigen Modifikation von @ Mareins Beispiel the_module.pysetzen wir ein

from proxy_tools import module_property

@module_property
def thing():
    print(". ", end='')  # Prints ". " on each invocation
    return 'hello'

Jetzt aus einem anderen Skript kann ich tun

import the_module

print(the_module.thing)
# . hello

Unerwartetes Verhalten

Diese Lösung ist nicht ohne Einschränkungen. Das heißt, the_module.thingist kein String ! Es ist ein proxy_tools.ProxyObjekt, dessen spezielle Methoden überschrieben wurden, damit es eine Zeichenfolge nachahmt. Hier sind einige grundlegende Tests, die den Punkt veranschaulichen:

res = the_module.thing
# [No output!!! Evaluation doesn't occur yet.]

print(type(res))
# <class 'proxy_tools.Proxy'>

print(isinstance(res, str))
# False

print(res)
# . hello

print(res + " there")
# . hello there

print(isinstance(res + "", str))
# . True

print(res.split('e'))
# . ['h', 'llo']

Intern wird die ursprüngliche Funktion gespeichert in the_module.thing._Proxy__local:

print(res._Proxy__local)
# <function thing at 0x7f729c3bf680>

Weitere Gedanken

Ehrlich gesagt bin ich verblüfft darüber, warum Module diese Funktionalität nicht eingebaut haben. Ich denke, der springende Punkt ist, dass the_modulees sich um eine Instanz der types.ModuleTypeKlasse handelt. Das Festlegen einer "Moduleigenschaft" entspricht dem Festlegen einer Eigenschaft für eine Instanz dieser Klasse und nicht für die types.ModuleTypeKlasse selbst. Weitere Einzelheiten finden Sie in dieser Antwort .

Wir können Eigenschaften types.ModuleTypewie folgt implementieren , obwohl die Ergebnisse nicht großartig sind. Wir können eingebaute Typen nicht direkt ändern, aber wir können sie verfluchen :

# python -m pip install forbiddenfruit
from forbiddenfruit import curse
from types import ModuleType
# curse has the same signature as setattr.
curse(ModuleType, "thing2", property(lambda module: f'hi from {module.__name__}'))

Dies gibt uns eine Eigenschaft, die über alle Module existiert. Es ist etwas unhandlich, da wir das Einstellungsverhalten über alle Module hinweg aufteilen:

import sys

print(sys.thing2)
# hi from sys

sys.thing2 = 5
# AttributeError: can't set attribute