モジュールに対する__getattr__

__getattr__クラスに、モジュールに同等のものをどのように実装できますか？

例

モジュールの静的に定義された属性に存在しない関数を呼び出すとき、そのモジュールでクラスのインスタンスを作成し、モジュールの属性ルックアップで失敗したのと同じ名前でそのメソッドを呼び出します。

class A(object):
    def salutation(self, accusative):
        print "hello", accusative

# note this function is intentionally on the module, and not the class above
def __getattr__(mod, name):
    return getattr(A(), name)

if __name__ == "__main__":
    # i hope here to have my __getattr__ function above invoked, since
    # salutation does not exist in the current namespace
    salutation("world")

それは与える：

matt@stanley:~/Desktop$ python getattrmod.py 
Traceback (most recent call last):
  File "getattrmod.py", line 9, in <module>
    salutation("world")
NameError: name 'salutation' is not defined

少し前に、Guidoは、新しいスタイルのクラスでのすべての特別なメソッドルックアップは__getattr__およびをバイパスすることを宣言しました__getattribute__。Dunder方法は、以前のモジュールで働いていた-あなたは、例えば、単純に定義することで、コンテキストマネージャとしてモジュールを使用することができます__enter__し、__exit__これらのトリックを前に、破りました。

最近、いくつかの歴史的な機能が復活し、__getattr__それらの中でモジュールが登場しました。そのため、既存のハック（sys.modulesインポート時にモジュールをそれ自体をクラスに置き換えるモジュール）は必要なくなりました。

Python 3.7以降では、1つの明白な方法を使用するだけです。モジュールの属性アクセスをカスタマイズするに__getattr__は、1つの引数（属性の名前）を受け入れる関数をモジュールレベルで定義し、計算された値を返すか、AttributeError：

# my_module.py

def __getattr__(name: str) -> Any:
    ...

これにより、「from」インポートへのフックも可能になります。つまり、などのステートメントに対して動的に生成されたオブジェクトを返すことができますfrom my_module import whatever。

関連する注記として、モジュールgetattrとともに、__dir__モジュールレベルで関数を定義してに応答することもできますdir(my_module)。詳細については、PEP 562を参照してください。

ここで発生している2つの基本的な問題があります。

1. __xxx__ メソッドはクラスでのみ検索されます
2. TypeError: can't set attributes of built-in/extension type 'module'

（1）どのソリューションでも、調査中のモジュールを追跡する必要があることを意味します。そうしないと、すべてのモジュールがインスタンス置換動作を持ちます。そして（2）は、（1）さえも不可能であることを意味します...少なくとも直接ではありません。

幸いなことに、sys.modulesはそこに行くものにうるさくないので、ラッパーは機能しますが、モジュールアクセス（つまりimport somemodule; somemodule.salutation('world')、同じモジュールアクセスの場合は、置換クラスのメソッドをヤンクして、それらをglobals()それぞれに追加する必要があります）クラスのカスタムメソッド（私はを使用するのが好き.export()）またはジェネリック関数（すでに回答としてリストされているものなど）を使用します。注意すべき点の1つは、ラッパーが毎回新しいインスタンスを作成していて、グローバルソリューションがそうでない場合、ああ、同時に両方を使用することはできません-どちらか一方です。

更新

グイド・ファン・ロッサムから：

実際に時々使用され、推奨されるハックがあります。モジュールは、必要な機能を備えたクラスを定義し、最後に、sys.modules内の自身をそのクラスのインスタンス（または主張する場合はクラス）で置き換えることができます。 、しかしそれは一般的にあまり役に立たない）。例えば：

# module foo.py

import sys

class Foo:
    def funct1(self, <args>): <code>
    def funct2(self, <args>): <code>

sys.modules[__name__] = Foo()

これが機能するのは、インポート機構がこのハックを積極的に有効にしているためです。最後のステップとして、実際のモジュールをロードした後、sys.modulesから引き出します。（これは偶然ではありません。このハッキングはずっと前に提案されたものであり、輸入機械でそれをサポートするのに十分に気に入っていると判断しました。）

したがって、目的を達成するための確立された方法は、モジュール内に単一のクラスを作成することです。モジュールの最後の動作として、sys.modules[__name__]クラスのインスタンスに置き換えます。これで、必要に応じて__getattr__/ __setattr__/で遊ぶことができ__getattribute__ます。

注1：この機能を使用する場合、sys.modules割り当てが行われると、モジュール内の他のすべて（グローバル、他の関数など）が失われます。したがって、必要なものがすべて置換クラス内にあることを確認してください。

注2：サポートfrom module import *するに__all__は、クラスで定義しておく必要があります。例えば：

class Foo:
    def funct1(self, <args>): <code>
    def funct2(self, <args>): <code>
    __all__ = list(set(vars().keys()) - {'__module__', '__qualname__'})

Pythonのバージョンによっては、から省略できる他の名前がある場合があります__all__。set()Pythonの2の互換性が必要とされていない場合は省略することができます。

これはハックですが、クラスでモジュールをラップすることができます：

class Wrapper(object):
  def __init__(self, wrapped):
    self.wrapped = wrapped
  def __getattr__(self, name):
    # Perform custom logic here
    try:
      return getattr(self.wrapped, name)
    except AttributeError:
      return 'default' # Some sensible default

sys.modules[__name__] = Wrapper(sys.modules[__name__])

私たちは通常そのようにはしません。

私たちがすることはこれです。

class A(object):
....

# The implicit global instance
a= A()

def salutation( *arg, **kw ):
    a.salutation( *arg, **kw )

どうして？したがって、暗黙的なグローバルインスタンスが表示されます。

例として、randomモジュールを見てください。これは、暗黙的なグローバルインスタンスを作成して、「単純な」乱数ジェネレータが必要なユースケースをわずかに簡略化します。

@HåvardSが提案したのと同様に、モジュール（など__getattr__）に魔法を実装する必要がある場合は、それを継承しtypes.ModuleTypeて配置する新しいクラスを定義しますsys.modules（おそらく、カスタムModuleTypeが定義されたモジュールを置き換えます）。

これのかなり堅牢な実装については__init__.py、Werkzeugのメインファイルを参照してください。

これはハッカですが...

import types

class A(object):
    def salutation(self, accusative):
        print "hello", accusative

    def farewell(self, greeting, accusative):
         print greeting, accusative

def AddGlobalAttribute(classname, methodname):
    print "Adding " + classname + "." + methodname + "()"
    def genericFunction(*args):
        return globals()[classname]().__getattribute__(methodname)(*args)
    globals()[methodname] = genericFunction

# set up the global namespace

x = 0   # X and Y are here to add them implicitly to globals, so
y = 0   # globals does not change as we iterate over it.

toAdd = []

def isCallableMethod(classname, methodname):
    someclass = globals()[classname]()
    something = someclass.__getattribute__(methodname)
    return callable(something)


for x in globals():
    print "Looking at", x
    if isinstance(globals()[x], (types.ClassType, type)):
        print "Found Class:", x
        for y in dir(globals()[x]):
            if y.find("__") == -1: # hack to ignore default methods
                if isCallableMethod(x,y):
                    if y not in globals(): # don't override existing global names
                        toAdd.append((x,y))


for x in toAdd:
    AddGlobalAttribute(*x)


if __name__ == "__main__":
    salutation("world")
    farewell("goodbye", "world")

これは、グローバル名前空間のすべてのオブジェクトを反復処理することで機能します。アイテムがクラスの場合、クラス属性を反復処理します。属性が呼び出し可能である場合、それは関数としてグローバル名前空間に追加されます。

「__」を含むすべての属性を無視します。

私はこれを量産コードでは使用しませんが、それであなたは始められるはずです。

ここに私自身の控えめな貢献があります-@HåvardSの高評価の回答を少し装飾したものですが、もう少し明示的です（そのため、おそらくOPには十分ではありませんが、@ S.Lottには受け入れられるかもしれません）。

import sys

class A(object):
    def salutation(self, accusative):
        print "hello", accusative

class Wrapper(object):
    def __init__(self, wrapped):
        self.wrapped = wrapped

    def __getattr__(self, name):
        try:
            return getattr(self.wrapped, name)
        except AttributeError:
            return getattr(A(), name)

_globals = sys.modules[__name__] = Wrapper(sys.modules[__name__])

if __name__ == "__main__":
    _globals.salutation("world")

クラスを含むモジュールファイルを作成します。モジュールをインポートします。getattrインポートしたモジュールで実行します。を使用して動的インポートを実行し、__import__sys.modulesからモジュールをプルできます。

ここにあなたのモジュールがありますsome_module.py：

class Foo(object):
    pass

class Bar(object):
    pass

そして別のモジュールで：

import some_module

Foo = getattr(some_module, 'Foo')

これを動的に行う：

import sys

__import__('some_module')
mod = sys.modules['some_module']
Foo = getattr(mod, 'Foo')