python - 既存のオブジェクトインスタンスへのメソッドの追加

Question

Pythonで既存のオブジェクト（つまり、クラス定義にない）にメソッドを追加できることを読みました。

そうすることが必ずしも良いとは限らないことを私は理解しています。しかし、どうすればこれを行うことができますか？

score 1073 · Accepted Answer

Python では、関数とバインドされたメソッドには違いがあります。

>>> def foo():
...     print "foo"
...
>>> class A:
...     def bar( self ):
...         print "bar"
...
>>> a = A()
>>> foo
<function foo at 0x00A98D70>
>>> a.bar
<bound method A.bar of <__main__.A instance at 0x00A9BC88>>
>>>

バインドされたメソッドはインスタンスに "バインド" (どの程度記述的か) されており、そのインスタンスはメソッドが呼び出されるたびに最初の引数として渡されます。

ただし、(インスタンスではなく) クラスの属性である Callable はまだバインドされていないため、いつでもクラス定義を変更できます。

>>> def fooFighters( self ):
...     print "fooFighters"
...
>>> A.fooFighters = fooFighters
>>> a2 = A()
>>> a2.fooFighters
<bound method A.fooFighters of <__main__.A instance at 0x00A9BEB8>>
>>> a2.fooFighters()
fooFighters

以前に定義されたインスタンスも更新されます (属性自体をオーバーライドしていない限り)。

>>> a.fooFighters()
fooFighters

メソッドを単一のインスタンスにアタッチする場合に問題が発生します。

>>> def barFighters( self ):
...     print "barFighters"
...
>>> a.barFighters = barFighters
>>> a.barFighters()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: barFighters() takes exactly 1 argument (0 given)

関数がインスタンスに直接アタッチされている場合、関数は自動的にバインドされません。

>>> a.barFighters
<function barFighters at 0x00A98EF0>

それをバインドするには、 types モジュールで MethodType 関数を使用できます。

>>> import types
>>> a.barFighters = types.MethodType( barFighters, a )
>>> a.barFighters
<bound method ?.barFighters of <__main__.A instance at 0x00A9BC88>>
>>> a.barFighters()
barFighters

今回は、クラスの他のインスタンスは影響を受けていません。

>>> a2.barFighters()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: A instance has no attribute 'barFighters'

詳細については、記述子とメタクラスプログラミングについての記事を参照してください。

score 135 · Accepted Answer

序文 - 互換性に関する注意: 他の回答は Python 2 でのみ機能する可能性があります - この回答は Python 2 および 3 で完全に機能するobjectはずです。 .

既存のオブジェクトインスタンスへのメソッドの追加

Python で既存のオブジェクト (たとえば、クラス定義ではない) にメソッドを追加できることを読みました。

そうすることが必ずしも良い決断ではないことは理解しています。しかし、どうすればこれを行うことができますか？

はい、可能ですが、お勧めしません

これはお勧めしません。これは悪い考えです。やらないでください。

いくつかの理由を次に示します。

これを行うすべてのインスタンスに、バインドされたオブジェクトを追加します。これを何度も行うと、おそらく多くのメモリが無駄になります。バインドされたメソッドは通常、呼び出しの短い期間だけ作成され、自動的にガベージコレクションが行われると存在しなくなります。これを手動で行うと、バインドされたメソッドを参照する名前バインディングが作成されます。これにより、使用時にガベージコレクションが行われなくなります。
通常、特定のタイプのオブジェクトインスタンスは、そのタイプのすべてのオブジェクトにメソッドを持ちます。メソッドを別の場所に追加すると、一部のインスタンスにはそれらのメソッドがあり、他のインスタンスにはありません。プログラマーはこれを予期せず、最小の驚きのルールに違反するリスクがあります。
これをやらないほうがいい理由は他にもあるので、そうすると評判も悪くなります。

したがって、よほどの理由がない限り、これを行わないことをお勧めします。クラス定義で正しいメソッドを定義する方がはるかに良いか、次のようにクラスに直接モンキーパッチを適用する方があまり好ましくありません。

Foo.sample_method = sample_method

しかし、それは有益なので、これを行ういくつかの方法を紹介します。

どのようにそれを行うことができます

ここにいくつかのセットアップコードがあります。クラス定義が必要です。インポートできますが、実際には問題ありません。

class Foo(object):
    '''An empty class to demonstrate adding a method to an instance'''

インスタンスを作成します。

foo = Foo()

それに追加するメソッドを作成します。

def sample_method(self, bar, baz):
    print(bar + baz)

Method naught (0) - ディスクリプタメソッドを使用します。`get`

関数のドット付きルックアップは__get__、インスタンスを使用して関数のメソッドを呼び出し、オブジェクトをメソッドにバインドして、「バインドされたメソッド」を作成します。

foo.sample_method = sample_method.__get__(foo)

そしていま：

>>> foo.sample_method(1,2)
3

方法 1 - types.MethodType

まず、メソッドコンストラクターを取得する型をインポートします。

import types

次に、メソッドをインスタンスに追加します。これを行うには、typesモジュールの MethodType コンストラクターが必要です (上記でインポートしました)。

types.MethodType (Python 3) の引数シグネチャは次のとおりです(function, instance)。

foo.sample_method = types.MethodType(sample_method, foo)

と使用法:

>>> foo.sample_method(1,2)
3

括弧を付けて、Python 2 の署名は(function, instance, class)次のとおりです。

foo.sample_method = types.MethodType(sample_method, foo, Foo)

方法 2: 字句バインディング

まず、メソッドをインスタンスにバインドするラッパー関数を作成します。

def bind(instance, method):
    def binding_scope_fn(*args, **kwargs): 
        return method(instance, *args, **kwargs)
    return binding_scope_fn

利用方法：

>>> foo.sample_method = bind(foo, sample_method)    
>>> foo.sample_method(1,2)
3

方法 3: functools.partial

部分関数は、最初の引数を関数 (およびオプションのキーワード引数) に適用し、後で残りの引数 (およびキーワード引数のオーバーライド) を使用して呼び出すことができます。したがって：

>>> from functools import partial
>>> foo.sample_method = partial(sample_method, foo)
>>> foo.sample_method(1,2)
3

これは、バインドされたメソッドがインスタンスの部分関数であることを考えると理にかなっています。

オブジェクト属性としてのバインドされていない関数 - これが機能しない理由:

クラスに追加する場合と同じ方法で sample_method を追加しようとすると、インスタンスからバインド解除され、最初の引数として暗黙の自己を取りません。

>>> foo.sample_method = sample_method
>>> foo.sample_method(1,2)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: sample_method() takes exactly 3 arguments (2 given)

インスタンス (または、このメソッドは実際にはself引数変数を使用しないため、何か) を明示的に渡すことで、バインドされていない関数を機能させることができますが、他のインスタンスの予想されるシグネチャとは一致しません (モンキーパッチを適用している場合)。このインスタンス):

>>> foo.sample_method(foo, 1, 2)
3

結論

これで、これを行う方法がいくつかわかりましたが、真剣に考えて、これを行わないでください。

score 42 · Accepted Answer

上記の回答は重要なポイントを逃したと思います。

メソッドを持つクラスを作成しましょう。

class A(object):
    def m(self):
        pass

それでは、ipython で遊んでみましょう。

In [2]: A.m
Out[2]: <unbound method A.m>

わかりましたので、m()はどういうわけかAのバインドされていないメソッドになります。しかし、それは本当にそうですか？

In [5]: A.__dict__['m']
Out[5]: <function m at 0xa66b8b4>

m()は単なる関数であり、その参照がAクラスディクショナリに追加されることがわかりました。魔法はありません。では、なぜAmはバインドされていないメソッドを提供するのでしょうか? これは、ドットが単純な辞書検索に変換されていないためです。これは事実上、A.__class__.__getattribute__(A, 'm') の呼び出しです。

In [11]: class MetaA(type):
   ....:     def __getattribute__(self, attr_name):
   ....:         print str(self), '-', attr_name

In [12]: class A(object):
   ....:     __metaclass__ = MetaA

In [23]: A.m
<class '__main__.A'> - m
<class '__main__.A'> - m

さて、なぜ最後の行が 2 回出力されるのか頭の中でよくわかりませんが、そこで何が起こっているのかは明らかです。

ここで、デフォルトの __getattribute__ が行うことは、属性がいわゆる記述子であるかどうか、つまり、特別な __get__ メソッドを実装しているかどうかをチェックすることです。そのメソッドを実装している場合、返されるのはその __get__ メソッドを呼び出した結果です。Aクラスの最初のバージョンに戻ると、次のようになります。

In [28]: A.__dict__['m'].__get__(None, A)
Out[28]: <unbound method A.m>

また、Python 関数は記述子プロトコルを実装しているため、オブジェクトに代わって呼び出された場合、__get__ メソッドでそのオブジェクトにバインドされます。

では、既存のオブジェクトにメソッドを追加するにはどうすればよいでしょうか? クラスにパッチを適用することを気にしないと仮定すると、それは次のように簡単です。

B.m = m

次に、ディスクリプタマジックのおかげで、 Bmはバインドされていないメソッドに「なります」。

また、1 つのオブジェクトだけにメソッドを追加する場合は、types.MethodType を使用して、自分で機械をエミュレートする必要があります。

b.m = types.MethodType(m, b)

ところで：

In [2]: A.m
Out[2]: <unbound method A.m>

In [59]: type(A.m)
Out[59]: <type 'instancemethod'>

In [60]: type(b.m)
Out[60]: <type 'instancemethod'>

In [61]: types.MethodType
Out[61]: <type 'instancemethod'>

score 27 · Accepted Answer

Pythonでは、モンキーパッチは通常、クラスまたは関数のシグネチャを独自のもので上書きすることで機能します。以下は、ZopeWikiの例です。

from SomeOtherProduct.SomeModule import SomeClass
def speak(self):
   return "ook ook eee eee eee!"
SomeClass.speak = speak

speakこのコードは、クラスで呼び出されるメソッドを上書き/作成します。モンキーパッチに関するJeffAtwoodの最近の投稿で、彼は私が仕事で使用している現在の言語であるC＃3.0の例を示しました。

score 18 · Accepted Answer

ラムダを使用して、メソッドをインスタンスにバインドできます。

def run(self):
    print self._instanceString

class A(object):
    def __init__(self):
        self._instanceString = "This is instance string"

a = A()
a.run = lambda: run(a)
a.run()

出力：

This is instance string

score 10 · Accepted Answer

あなたが探しているのは、setattr私が信じていることです。これを使用して、オブジェクトに属性を設定します。

>>> def printme(s): print repr(s)
>>> class A: pass
>>> setattr(A,'printme',printme)
>>> a = A()
>>> a.printme() # s becomes the implicit 'self' variable
< __ main __ . A instance at 0xABCDEFG>

score 7 · Accepted Answer

Jason Prattとコミュニティwikiの回答を統合し、さまざまなバインド方法の結果を確認します。

特に、バインディング関数をクラスメソッドとして追加する方法に注意してください。ただし、参照スコープは正しくありません。

#!/usr/bin/python -u
import types
import inspect

## dynamically adding methods to a unique instance of a class


# get a list of a class's method type attributes
def listattr(c):
    for m in [(n, v) for n, v in inspect.getmembers(c, inspect.ismethod) if isinstance(v,types.MethodType)]:
        print m[0], m[1]

# externally bind a function as a method of an instance of a class
def ADDMETHOD(c, method, name):
    c.__dict__[name] = types.MethodType(method, c)

class C():
    r = 10 # class attribute variable to test bound scope

    def __init__(self):
        pass

    #internally bind a function as a method of self's class -- note that this one has issues!
    def addmethod(self, method, name):
        self.__dict__[name] = types.MethodType( method, self.__class__ )

    # predfined function to compare with
    def f0(self, x):
        print 'f0\tx = %d\tr = %d' % ( x, self.r)

a = C() # created before modified instnace
b = C() # modified instnace


def f1(self, x): # bind internally
    print 'f1\tx = %d\tr = %d' % ( x, self.r )
def f2( self, x): # add to class instance's .__dict__ as method type
    print 'f2\tx = %d\tr = %d' % ( x, self.r )
def f3( self, x): # assign to class as method type
    print 'f3\tx = %d\tr = %d' % ( x, self.r )
def f4( self, x): # add to class instance's .__dict__ using a general function
    print 'f4\tx = %d\tr = %d' % ( x, self.r )


b.addmethod(f1, 'f1')
b.__dict__['f2'] = types.MethodType( f2, b)
b.f3 = types.MethodType( f3, b)
ADDMETHOD(b, f4, 'f4')


b.f0(0) # OUT: f0   x = 0   r = 10
b.f1(1) # OUT: f1   x = 1   r = 10
b.f2(2) # OUT: f2   x = 2   r = 10
b.f3(3) # OUT: f3   x = 3   r = 10
b.f4(4) # OUT: f4   x = 4   r = 10


k = 2
print 'changing b.r from {0} to {1}'.format(b.r, k)
b.r = k
print 'new b.r = {0}'.format(b.r)

b.f0(0) # OUT: f0   x = 0   r = 2
b.f1(1) # OUT: f1   x = 1   r = 10  !!!!!!!!!
b.f2(2) # OUT: f2   x = 2   r = 2
b.f3(3) # OUT: f3   x = 3   r = 2
b.f4(4) # OUT: f4   x = 4   r = 2

c = C() # created after modifying instance

# let's have a look at each instance's method type attributes
print '\nattributes of a:'
listattr(a)
# OUT:
# attributes of a:
# __init__ <bound method C.__init__ of <__main__.C instance at 0x000000000230FD88>>
# addmethod <bound method C.addmethod of <__main__.C instance at 0x000000000230FD88>>
# f0 <bound method C.f0 of <__main__.C instance at 0x000000000230FD88>>

print '\nattributes of b:'
listattr(b)
# OUT:
# attributes of b:
# __init__ <bound method C.__init__ of <__main__.C instance at 0x000000000230FE08>>
# addmethod <bound method C.addmethod of <__main__.C instance at 0x000000000230FE08>>
# f0 <bound method C.f0 of <__main__.C instance at 0x000000000230FE08>>
# f1 <bound method ?.f1 of <class __main__.C at 0x000000000237AB28>>
# f2 <bound method ?.f2 of <__main__.C instance at 0x000000000230FE08>>
# f3 <bound method ?.f3 of <__main__.C instance at 0x000000000230FE08>>
# f4 <bound method ?.f4 of <__main__.C instance at 0x000000000230FE08>>

print '\nattributes of c:'
listattr(c)
# OUT:
# attributes of c:
# __init__ <bound method C.__init__ of <__main__.C instance at 0x0000000002313108>>
# addmethod <bound method C.addmethod of <__main__.C instance at 0x0000000002313108>>
# f0 <bound method C.f0 of <__main__.C instance at 0x0000000002313108>>

個人的には、外部のADDMETHOD関数ルートを好みます。これにより、イテレーター内でも新しいメソッド名を動的に割り当てることができます。

def y(self, x):
    pass
d = C()
for i in range(1,5):
    ADDMETHOD(d, y, 'f%d' % i)
print '\nattributes of d:'
listattr(d)
# OUT:
# attributes of d:
# __init__ <bound method C.__init__ of <__main__.C instance at 0x0000000002303508>>
# addmethod <bound method C.addmethod of <__main__.C instance at 0x0000000002303508>>
# f0 <bound method C.f0 of <__main__.C instance at 0x0000000002303508>>
# f1 <bound method ?.y of <__main__.C instance at 0x0000000002303508>>
# f2 <bound method ?.y of <__main__.C instance at 0x0000000002303508>>
# f3 <bound method ?.y of <__main__.C instance at 0x0000000002303508>>
# f4 <bound method ?.y of <__main__.C instance at 0x0000000002303508>>

score 7 · Accepted Answer

この質問は Python 以外のバージョンを求めているため、JavaScript は次のとおりです。

a.methodname = function () { console.log("Yay, a new method!") }

score 7 · Accepted Answer

これは実際には「Jason Pratt」の回答へのアドオンです

ジェイソンの答えは機能しますが、クラスに関数を追加したい場合にのみ機能します。.py ソースコードファイルから既存のメソッドをリロードしようとしたときに、うまくいきませんでした。

回避策を見つけるのに何年もかかりましたが、トリックは簡単に思えます... 1.ソースコードファイルからコードをインポートします 2.リロードを強制します 3.types.FunctionType(...)を使用して変換しますメソッドを関数にインポートしてバインドすると、現在のグローバル変数を渡すこともできます。リロードされたメソッドは別の名前空間にあるためです。 )

例：

# this class resides inside ReloadCodeDemo.py
class A:
    def bar( self ):
        print "bar1"
        
    def reloadCode(self, methodName):
        ''' use this function to reload any function of class A'''
        import types
        import ReloadCodeDemo as ReloadMod # import the code as module
        reload (ReloadMod) # force a reload of the module
        myM = getattr(ReloadMod.A,methodName) #get reloaded Method
        myTempFunc = types.FunctionType(# convert the method to a simple function
                                myM.im_func.func_code, #the methods code
                                globals(), # globals to use
                                argdefs=myM.im_func.func_defaults # default values for variables if any
                                ) 
        myNewM = types.MethodType(myTempFunc,self,self.__class__) #convert the function to a method
        setattr(self,methodName,myNewM) # add the method to the function

if __name__ == '__main__':
    a = A()
    a.bar()
    # now change your code and save the file
    a.reloadCode('bar') # reloads the file
    a.bar() # now executes the reloaded code

score 5 · Accepted Answer

この質問は何年も前に開かれましたが、デコレータを使用してクラスインスタンスへの関数のバインドをシミュレートする簡単な方法があります。

def binder (function, instance):
  copy_of_function = type (function) (function.func_code, {})
  copy_of_function.__bind_to__ = instance
  def bound_function (*args, **kwargs):
    return copy_of_function (copy_of_function.__bind_to__, *args, **kwargs)
  return bound_function


class SupaClass (object):
  def __init__ (self):
    self.supaAttribute = 42


def new_method (self):
  print self.supaAttribute


supaInstance = SupaClass ()
supaInstance.supMethod = binder (new_method, supaInstance)

otherInstance = SupaClass ()
otherInstance.supaAttribute = 72
otherInstance.supMethod = binder (new_method, otherInstance)

otherInstance.supMethod ()
supaInstance.supMethod ()

そこで、関数とインスタンスをバインダーデコレーターに渡すと、最初のコードオブジェクトと同じコードオブジェクトを使用して、新しい関数が作成されます。次に、指定されたクラスのインスタンスが、新しく作成された関数の属性に格納されます。デコレーターは、コピーされた関数を自動的に呼び出す (3 番目の) 関数を返し、インスタンスを最初のパラメーターとして指定します。

結論として、クラスインスタンスへのバインドをシミュレートする関数を取得します。本来の機能をそのままに。

score 4 · Accepted Answer

少しでもお役に立てれば、私は最近、モンキーパッチのプロセスをより便利にするために、Gorilla という名前の Python ライブラリをリリースしました。

関数needle()を使用して、という名前のモジュールにパッチを適用するとguineapig、次のようになります。

import gorilla
import guineapig
@gorilla.patch(guineapig)
def needle():
    print("awesome")

しかし、ドキュメンテーションの FAQに示されているように、より興味深いユースケースにも対応しています。

コードはGitHubで入手できます。

score 3 · Accepted Answer

ジェイソン・プラットが投稿したものは正しいです。

>>> class Test(object):
...   def a(self):
...     pass
... 
>>> def b(self):
...   pass
... 
>>> Test.b = b
>>> type(b)
<type 'function'>
>>> type(Test.a)
<type 'instancemethod'>
>>> type(Test.b)
<type 'instancemethod'>

ご覧のとおり、Python は b() を a() と何ら異なるものとは見なしません。Python では、すべてのメソッドはたまたま関数である単なる変数です。

score 3 · Accepted Answer

from types import MethodType

def method(self):
   print 'hi!'


setattr( targetObj, method.__name__, MethodType(method, targetObj, type(method)) )

これでセルフポインタが使えるようになります

python - 既存のオブジェクトインスタンスへのメソッドの追加

18 に答える 18

既存のオブジェクト インスタンスへのメソッドの追加

はい、可能ですが、お勧めしません

どのようにそれを行うことができます

Method naught (0) - ディスクリプタ メソッドを使用します。__get__

方法 1 - types.MethodType

方法 2: 字句バインディング

方法 3: functools.partial

オブジェクト属性としてのバインドされていない関数 - これが機能しない理由:

結論

これは実際には「Jason Pratt」の回答へのアドオンです

Related

Reference

既存のオブジェクトインスタンスへのメソッドの追加

Method naught (0) - ディスクリプタメソッドを使用します。`get`