Les modules peuvent-ils avoir les mêmes propriétés que les objets?

Question

Avec des propriétés de python, je peux le faire de telle sorte que

obj.y 

appelle une fonction plutôt que de retourner une valeur.

Existe-t-il un moyen de faire cela avec les modules? J'ai un cas où je veux

module.y 

d'appeler une fonction, plutôt que de simplement retourner la valeur stockée là.

Answer 1

Seules les instances de classes de style nouveau peuvent avoir des propriétés. Vous pouvez faire croire à Python qu'une telle instance est un module en la stockant dans sys.modules[thename] = theinstance. Ainsi, par exemple, votre fichier module m.py pourrait être:

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() 

_{Edité: supprimé une dépendance implicite globals (n'a rien à voir avec le point de l'exemple mais ne confondez pas les choses en faisant la le code original échoue!).}

Answer 2

je ferais ceci afin d'hériter correctement tous les attributs d'un module et être correctement identifiés par isinstance()

import types 

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


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

Et puis vous pouvez insérer dans ce sys.modules:

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

Answer 3

Un cas d'utilisation typique est: enrichir un module (énorme) existant avec quelques (quelques) attributs dynamiques - sans transformer tout le contenu du module en une présentation de classe. Malheureusement, un correctif de classe de module plus simple comme sys.modules[__name__].__class__ = MyPropertyModule échoue avec TypeError: __class__ assignment: only for heap types. La création du module doit donc être recâblée.

cette approche, il fait sans crochets d'importation Python, tout en ayant une Prolog au-dessus du code du module:

# 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) 

Utilisation:

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

Note: Quelque chose comme from propertymodule import dynval produira une gelée copie du cours - correspondant à dynval = someobject.dynval