Python __call__特殊メソッドの実用的な例

__call__クラスのインスタンスが呼び出されると、クラスのメソッドがトリガーされることを知っています。ただし、この特別なメソッドをいつ使用できるかわかりません。単に新しいメソッドを作成して、メソッドで行われたのと同じ操作を実行__call__でき、インスタンスを呼び出す代わりにメソッドを呼び出すことができるためです。

誰かがこの特別な方法の実用的な使用法を教えてくれれば本当にありがたいです。

Djangoフォームモジュールは__call__メソッドを適切に使用して、フォーム検証用の一貫したAPIを実装します。Djangoのフォームに独自のバリデーターを関数として書くことができます。

def custom_validator(value):
    #your validation logic

Djangoには、メールバリデーター、URLバリデーターなど、デフォルトの組み込みバリデーターがいくつかあります。これらは、広くRegExバリデーターの傘下にあります。これらをきれいに実装するために、Djangoは（関数ではなく）呼び出し可能なクラスに頼っています。RegexValidatorにデフォルトのRegex検証ロジックを実装し、他の検証用にこれらのクラスを拡張します。

class RegexValidator(object):
    def __call__(self, value):
        # validation logic

class URLValidator(RegexValidator):
    def __call__(self, value):
        super(URLValidator, self).__call__(value)
        #additional logic

class EmailValidator(RegexValidator):
    # some logic

これで、カスタム関数と組み込みのEmailValidatorの両方を同じ構文で呼び出すことができます。

for v in [custom_validator, EmailValidator()]:
    v(value) # <-----

ご覧のとおり、Djangoでのこの実装は、他の人が以下の回答で説明したものと似ています。これは他の方法で実装できますか？できますが、私見では、Djangoのような大きなフレームワークに対しては、読みやすく、拡張も容易ではありません。

この例ではメモ化を使用しており、基本的に値をテーブル（この場合は辞書）に格納しているため、後で再計算する代わりに後で調べることができます。

ここでは、静的変数を含む階乗関数（Pythonでは不可能）の代わりに、__call__（呼び出し可能オブジェクトを介して）階乗を計算するメソッドを持つ単純なクラスを使用します。

class Factorial:
    def __init__(self):
        self.cache = {}
    def __call__(self, n):
        if n not in self.cache:
            if n == 0:
                self.cache[n] = 1
            else:
                self.cache[n] = n * self.__call__(n-1)
        return self.cache[n]

fact = Factorial()

これでfact、他のすべての関数と同様に、呼び出し可能なオブジェクトができました。例えば

for i in xrange(10):                                                             
    print("{}! = {}".format(i, fact(i)))

# output
0! = 1
1! = 1
2! = 2
3! = 6
4! = 24
5! = 120
6! = 720
7! = 5040
8! = 40320
9! = 362880

そしてそれはまたステートフルです。

使いやすく（特定の引数を必要とする呼び出し可能なオブジェクトがいくつかあります）、オブジェクト指向の手法を使用できるので実装が簡単なAPIを作成できるので便利です。

以下は、昨日書いたコードhashlib.fooで、文字列ではなくファイル全体をハッシュするメソッドのバージョンを作成します。

# filehash.py
import hashlib


class Hasher(object):
    """
    A wrapper around the hashlib hash algorithms that allows an entire file to
    be hashed in a chunked manner.
    """
    def __init__(self, algorithm):
        self.algorithm = algorithm

    def __call__(self, file):
        hash = self.algorithm()
        with open(file, 'rb') as f:
            for chunk in iter(lambda: f.read(4096), ''):
                hash.update(chunk)
        return hash.hexdigest()


md5    = Hasher(hashlib.md5)
sha1   = Hasher(hashlib.sha1)
sha224 = Hasher(hashlib.sha224)
sha256 = Hasher(hashlib.sha256)
sha384 = Hasher(hashlib.sha384)
sha512 = Hasher(hashlib.sha512)

この実装により、関数と同様の方法で関数を使用できhashlib.fooます。

from filehash import sha1
print sha1('somefile.txt')

もちろん、別の方法で実装することもできますが、この場合は単純なアプローチのように見えました。

__call__Pythonでデコレータクラスを実装するためにも使用されます。この場合、デコレータ付きのメソッドが呼び出されると、クラスのインスタンスが呼び出されます。

class EnterExitParam(object):

    def __init__(self, p1):
        self.p1 = p1

    def __call__(self, f):
        def new_f():
            print("Entering", f.__name__)
            print("p1=", self.p1)
            f()
            print("Leaving", f.__name__)
        return new_f


@EnterExitParam("foo bar")
def hello():
    print("Hello")


if __name__ == "__main__":
    hello()

はい、オブジェクトを扱っていることがわかっている場合は、明示的なメソッド呼び出しを使用することが完全に可能です（多くの場合は推奨されます）。ただし、呼び出し可能なオブジェクト（通常は機能しますが、__call__場合がありますが、インスタンスデータや、呼び出し可能な繰り返しのタスクなどを委任するメソッドなどを使用して、より複雑なオブジェクトを構築できます。

また、複雑なタスク（専用クラスを書くのが理にかなっている場合）と単純なタスク（関数に既に存在するか、関数としてより簡単に記述できる場合）の両方のオブジェクトを使用している場合もあります。共通のインターフェースを使用するには、これらの関数を期待されるインターフェースでラップする小さなクラスを作成するか、または関数を保持してより複雑なオブジェクトを呼び出し可能にする必要があります。スレッドを例に考えてみましょう。Thread標準ライブラリモジュールthreadingのオブジェクトには、target引数として（つまり、新しいスレッドで実行されるアクションとして）呼び出し可能オブジェクトが必要です。呼び出し可能オブジェクトを使用すると、関数に限定されず、他のスレッドからタスクを実行してそれらを順次実行する比較的複雑なワーカーなど、他のオブジェクトも渡すことができます。

class Worker(object):
    def __init__(self, *args, **kwargs):
        self.queue = queue.Queue()
        self.args = args
        self.kwargs = kwargs

    def add_task(self, task):
        self.queue.put(task)

    def __call__(self):
        while True:
            next_action = self.queue.get()
            success = next_action(*self.args, **self.kwargs)
            if not success:
               self.add_task(next_action)

これは頭​​の上の例にすぎませんが、クラスを正当化するのに十分なほど複雑になっていると思います。関数だけでこれを行うのは困難です。少なくとも、2つの関数を返す必要があり、徐々に複雑になっています。一つは、可能性が名前を変更__call__別のものに限定法を渡すが、それはやや明瞭でスレッドを作成するコードを作成し、任意の値を追加しません。

クラスベースのデコレータは__call__、ラップされた関数を参照するために使用します。例えば：

class Deco(object):
    def __init__(self,f):
        self.f = f
    def __call__(self, *args, **kwargs):
        print args
        print kwargs
        self.f(*args, **kwargs)

Artima.comには、さまざまなオプションの詳しい説明があります。

IMHO __call__メソッドとクロージャーは、PythonでSTRATEGYデザインパターンを作成する自然な方法を提供します。アルゴリズムのファミリーを定義し、それぞれをカプセル化し、それらを交換可能にして、最終的に、共通の一連のステップを実行し、たとえば、ファイルのハッシュを計算できます。

綺麗だと思う__call__()コンサートの使い方を偶然見つけました__getattr__()。オブジェクト内のJSON / HTTP /（however_serialized）APIの複数のレベルを非表示にすることができます。

この__getattr__()パーツは、同じクラスの変更されたインスタンスを繰り返し返すことを担当し、一度に1つ以上の属性を入力します。次に、すべての情報を使い果たした後、__call__()渡した引数を引き継ぎます。

このモデルを使用すると、たとえばのような呼び出しを行うことができapi.v2.volumes.ssd.update(size=20)、最終的にはへのPUTリクエストになりhttps://some.tld/api/v2/volumes/ssd/updateます。

特定のコードは、OpenStackの特定のボリュームバックエンド用のブロックストレージドライバーです。https：//github.com/openstack/cinder/blob/master/cinder/volume/drivers/nexenta/jsonrpc.pyで確認できます。

編集：マスターリビジョンを指すようにリンクを更新しました。

メソッドを指定し__metaclass__て__call__メソッドをオーバーライドし、指定されたメタクラスの__new__メソッドがクラスのインスタンスを返すようにします。ビオラにはメソッドを持つ「関数」があります。

__call__methodを使用して、他のクラスメソッドを静的メソッドとして使用できます。

    class _Callable:
        def __init__(self, anycallable):
            self.__call__ = anycallable

    class Model:

        def get_instance(conn, table_name):

            """ do something"""

        get_instance = _Callable(get_instance)

    provs_fac = Model.get_instance(connection, "users")             

一つの一般的な例である__call__にfunctools.partialここで、簡略化バージョンである（とはPython> = 3.5）。

class partial:
    """New function with partial application of the given arguments and keywords."""

    def __new__(cls, func, *args, **kwargs):
        if not callable(func):
            raise TypeError("the first argument must be callable")
        self = super().__new__(cls)

        self.func = func
        self.args = args
        self.kwargs = kwargs
        return self

    def __call__(self, *args, **kwargs):
        return self.func(*self.args, *args, **self.kwargs, **kwargs)

使用法：

def add(x, y):
    return x + y

inc = partial(add, y=1)
print(inc(41))  # 42

関数呼び出し演算子。

class Foo:
    def __call__(self, a, b, c):
        # do something

x = Foo()
x(1, 2, 3)

__call__方法は/再初期化、同じオブジェクトを再定義するために使用することができます。また、オブジェクトに引数を渡すことで、クラスのインスタンス/オブジェクトを関数として簡単に使用できます。

私は、呼び出し可能オブジェクトを使用するのに適した場所を見つけ、定義しているものが__call__()のような、Pythonで関数型プログラミング機能を使用する場合、ありますmap()、filter()、reduce()。

プレーン関数またはラムダ関数に対して呼び出し可能オブジェクトを使用するのに最適なタイミングは、ロジックが複雑で、状態を保持する必要がある場合や、__call__()関数に渡されない他の情報を使用する場合です。

次に、呼び出し可能なオブジェクトとを使用して、ファイル名拡張子に基づいてファイル名をフィルタリングするコードをいくつか示しますfilter()。

呼び出し可能：

import os

class FileAcceptor(object):
    def __init__(self, accepted_extensions):
        self.accepted_extensions = accepted_extensions

    def __call__(self, filename):
        base, ext = os.path.splitext(filename)
        return ext in self.accepted_extensions

class ImageFileAcceptor(FileAcceptor):
    def __init__(self):
        image_extensions = ('.jpg', '.jpeg', '.gif', '.bmp')
        super(ImageFileAcceptor, self).__init__(image_extensions)

使用法：

filenames = [
    'me.jpg',
    'me.txt',
    'friend1.jpg',
    'friend2.bmp',
    'you.jpeg',
    'you.xml']

acceptor = ImageFileAcceptor()
image_filenames = filter(acceptor, filenames)
print image_filenames

出力：

['me.jpg', 'friend1.jpg', 'friend2.bmp', 'you.jpeg']

これは遅すぎますが、私は例を挙げています。あなたが持っている想像VectorクラスとPointクラスを。どちらもx, y位置引数として使用します。ベクトル上に配置するポイントを移動する関数を作成したいとしましょう。

4ソリューション

• put_point_on_vec(point, vec)

• これをvectorクラスのメソッドにします。例えば my_vec.put_point(point)

• それをPointクラスのメソッドにします。my_point.put_on_vec(vec)
• Vector実装__call__するので、次のように使用できますmy_vec_instance(point)

これは実際には、遅かれ早かれリリースするMathsで説明されているdunderメソッドのガイドのために取り組んでいるいくつかの例の一部です。

これはこの質問についてのことではないので、ポイント自体を移動する論理を残しました