서문-호환성에 대한 참고 사항 : 다른 답변은 Python 2에서만 작동 할 수 있습니다.이 답변은 Python 2 및 3에서 완벽하게 작동합니다. Python 3 만 작성하는 경우 명시 적으로 상속 object하지 않을 수 있지만 코드가 동일하게 유지되어야합니다 .

기존 객체 인스턴스에 메소드 추가

파이썬에서 기존 객체 (예 : 클래스 정의가 아닌)에 메소드를 추가하는 것이 가능하다는 것을 읽었습니다.

그렇게하는 것이 항상 좋은 결정은 아니라는 것을 이해합니다. 그러나 어떻게 이것을 할 수 있습니까?

예, 가능하지만 권장하지 않습니다

나는 이것을 권장하지 않습니다. 이것은 나쁜 생각입니다. 하지마

몇 가지 이유는 다음과 같습니다.

• 이 작업을 수행하는 모든 인스턴스에 바인딩 된 개체를 추가합니다. 이 작업을 많이하면 메모리가 많이 낭비 될 수 있습니다. 바운드 메서드는 일반적으로 짧은 호출 기간 동안 만 생성 된 다음 자동으로 가비지 수집시 존재하지 않습니다. 이 작업을 수동으로 수행하면 바인딩 된 메서드를 참조하는 이름 바인딩이 생겨서 사용시 가비지 수집이 방지됩니다.
• 주어진 유형의 객체 인스턴스에는 일반적으로 해당 유형의 모든 객체에 대한 메소드가 있습니다. 다른 곳에서 메소드를 추가하면 일부 인스턴스에는 해당 메소드가 있고 다른 인스턴스에는 그렇지 않습니다. 프로그래머는 이것을 기대하지 않을 것이며, 놀랍게도 규칙을 위반할 위험이 있습니다 .
• 이것을하지 말아야 할 다른 좋은 이유들이 있기 때문에, 그렇게하면 자신에게 나쁜 평판을 줄 것입니다.

따라서 나는 당신이 정말로 좋은 이유가 없다면 이것을하지 말 것을 권한다. 이 클래스 정의에 올바른 방법을 정의하는 데 훨씬 더 또는 덜 같이, 바람직하게는 원숭이 패치 클래스를 직접 :

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)

메소드 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의 인수 서명은 (function, instance, class)다음과 같습니다.

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

그리고 사용법 :

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

방법 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

결론

당신은 지금 당신 이 이것을 할 수 있는 몇 가지 방법을 알고 있지만, 진지하게-이것을하지 마십시오.

답변

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

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

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

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

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

B.m = m

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

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

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

>>> class A:
...  def m(self):
...   print 'im m, invoked with: ', self

>>> a = A()
>>> a.m()
im m, invoked with:  <__main__.A instance at 0x973ec6c>
>>> a.m
<bound method A.m of <__main__.A instance at 0x973ec6c>>
>>>
>>> def foo(firstargument):
...  print 'im foo, invoked with: ', firstargument

>>> foo
<function foo at 0x978548c>

>>> a.foo = foo.__get__(a, A) # or foo.__get__(a, type(a))
>>> a.foo()
im foo, invoked with:  <__main__.A instance at 0x973ec6c>
>>> a.foo
<bound method A.foo of <__main__.A instance at 0x973ec6c>>

>>> instancemethod = type(A.m)
>>> instancemethod
<type 'instancemethod'>
>>> a.foo2 = instancemethod(foo, a, type(a))
>>> a.foo2()
im foo, invoked with:  <__main__.A instance at 0x973ec6c>
>>> a.foo2
<bound method instance.foo of <__main__.A instance at 0x973ec6c>>