Hinzufügen einer Methode zu einer Vorhandenen Objekt-Instanz

08-06-2019
|

Frage

Ich habe gelesen, dass es möglich ist, eine Methode zum hinzufügen eines vorhandenen Objekts (D. H., nicht in der definition der Klasse) in Python.

Ich verstehe, dass es nicht immer gut, dies zu tun.Aber wie könnte man dies tun?

Lösung

In Python gibt es einen Unterschied zwischen Funktionen und-bound-Methoden.

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

Bound-Methoden wurden "gebunden" (wie Beschreibung) auf eine Instanz, und diese Instanz als erstes argument übergeben, wenn die Methode aufgerufen wird.

Callables, dass sind die Attribute einer Klasse (im Gegensatz zu einer Instanz) sind noch ungebunden, obwohl, so können Sie ändern die definition der Klasse, Wann immer Sie wollen:

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

Zuvor definierte Instanzen aktualisiert haben (solange Sie noch nicht überschrieben das Attribut selbst):

>>> a.fooFighters()
fooFighters

Das problem kommt, wenn Sie möchten, fügen Sie eine Methode, um eine einzelne Instanz:

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

Die Funktion ist nicht automatisch, wenn es angeschlossen ist, um eine Instanz:

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

Es zu binden, können wir die MethodType Funktion in der Typen-Modul:

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

Dieses mal andere Instanzen der Klasse nicht betroffen sind:

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

Mehr Informationen können gefunden werden durch die Lektüre über Deskriptoren und metaclass Programmierung.

Andere Tipps

Modul neue ist veraltet seit python 2.6 und entfernt 3.0 Typen

finden http://docs.python.org/library/new.html

Im Beispiel unten habe ich absichtlich entfernt Rückgabewert patch_me() Funktion.Ich denke, dass die Rückkehr Wert zu machen kann man glauben, dass patch gibt ein neues Objekt, das ist nicht wahr - es ändert die ankommenden ein.Wahrscheinlich ist dies erleichtern kann ein disziplinierter Einsatz von monkeypatching.

import types

class A(object):#but seems to work for old style objects too
    pass

def patch_me(target):
    def method(target,x):
        print "x=",x
        print "called from", target
    target.method = types.MethodType(method,target)
    #add more if needed

a = A()
print a
#out: <__main__.A object at 0x2b73ac88bfd0>  
patch_me(a)    #patch instance
a.method(5)
#out: x= 5
#out: called from <__main__.A object at 0x2b73ac88bfd0>
patch_me(A)
A.method(6)        #can patch class too
#out: x= 6
#out: called from <class '__main__.A'>

Vorwort - ein Hinweis auf Kompatibilität:andere Antworten dürfen nur in Python 2 - die Antwort sollte perfekt funktionieren in Python 2 und 3.Wenn das schreiben von Python 3 nur, Sie könnte verlassen sich ausdrücklich von Erben object, aber ansonsten ist der code sollte der gleiche bleiben.

Hinzufügen einer Methode zu einer Vorhandenen Objekt-Instanz

Ich habe gelesen, dass es möglich ist, eine Methode zum hinzufügen zu einem bestehenden Objekt (z.B.nicht in der definition der Klasse) in Python.

Ich verstehe, dass es nicht immer eine gute Entscheidung, dies zu tun. Aber, wie könnte man dies tun?

Ja, es ist möglich, Aber nicht empfohlen

Ich weiß nicht empfehlen diese.Dies ist eine schlechte Idee.Tun Sie es nicht.

Hier ein paar Gründe:

Fügen Sie eine gebundene Objekt an jede Instanz, die Sie tun, um.Wenn Sie dies tun eine Menge, Sie werden wahrscheinlich verlieren viel Speicher.Bound-Methoden sind in der Regel nur erstellt, für die kurze Dauer Ihres Gesprächs und Sie dann aufhören zu existieren, wenn Sie automatisch Müll gesammelt.Wenn Sie dies manuell tun, müssen Sie einen Namen verbindliches verweisen auf die gebundene Methode - die Verhinderung der garbage collection, die auf der Nutzung.
Objekt Instanzen eines bestimmten Typs haben in der Regel seine Methoden für alle Objekte dieses Typs.Wenn Sie fügen Sie Methoden, die anderswo einigen Fällen werden diese Methoden und andere nicht.Programmierer nicht erwarten, dass diese, und Sie Gefahr laufen, gegen die Regel der geringsten überraschung.
Da gibt es andere wirklich gute Gründe, dies nicht zu tun, werden Sie zusätzlich geben Sie sich einen schlechten Ruf, wenn Sie es tun.

Also, ich schlage vor, dass Sie dies nicht tun, es sei denn, Sie haben einen wirklich guten Grund. Es ist weit besser zu definieren, die richtige Methode in der Klassendefinition oder weniger vorzugsweise auf die Affen-patch der Klasse direkt, wie diese:

Foo.sample_method = sample_method

Seit es ist sehr lehrreich, aber ich zeige Ihnen einige Möglichkeiten, dies zu tun.

Wie kann es getan werden

Hier einige setup-code.Wir müssen die definition einer Klasse.Es könnte importiert werden, aber es spielt wirklich keine Rolle.

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

Erstellen Sie eine Instanz:

foo = Foo()

Erstellen Sie eine Methode, um es hinzuzufügen:

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

Methode null (0) - verwenden Sie die Deskriptor-Methode, `get`

Gepunktete lookups auf Funktionen rufen Sie die __get__ Methode der Funktion mit der Instanz, die Bindung des Objekts an die Methode und damit die Schaffung einer "gebundenen Methode."

foo.sample_method = sample_method.__get__(foo)

und jetzt:

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

Methode eins - Typen.MethodType

Importieren Sie zunächst die Typen, aus denen wir kommen auf die Konstruktor-Methode:

import types

Fügen wir nun die Methode der Instanz.Um dies zu tun, benötigen wir die MethodType-Konstruktor aus dem types Modul (die wir importiert oben).

Das argument Signatur-Typen.MethodType ist (function, instance, class):

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

und Verwendung:

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

Methode zwei:lexikalische Bindung

Zuerst erstellen Sie eine wrapper-Funktion, bindet die Methode der Instanz:

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

Verwendung:

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

Methode drei:functools.teilweise

Eine partielle Funktion gilt das erste argument(s) einer Funktion (und Optional-Schlüsselwort-Argumente), und können später aufgerufen werden, mit den restlichen Argumente (und override-Schlüsselwort-Argumente).Also:

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

Das macht Sinn, wenn man bedenkt, dass der bound-Methoden sind teilweise Funktionen der Instanz.

Unbound Funktion als Objekt-Attribut - warum dies nicht funktioniert:

Wenn wir versuchen, fügen Sie die sample_method in der gleichen Weise, wie wir könnten, fügen Sie Sie der Klasse, es ist losgebunden, von der Instanz, und nicht die implizite self als erstes argument.

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

Wir können machen die ungebundenen Funktion arbeiten, indem Sie explizit die Weitergabe der Instanz (oder nichts, da Sie diese Methode nicht nutzen self argument-variable), aber es wäre nicht im Einklang mit der erwarteten Unterzeichnung anderen Fällen (wenn wir die monkey-patching in diesem Beispiel):

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

Fazit

Jetzt wissen Sie mehrere Möglichkeiten, wie Sie könnte tun Sie dies, aber in aller Ernsthaftigkeit - nicht tun.

Ich denke, dass die oben genannten Antworten, verpasste der entscheidende Punkt.

Wir haben eine Klasse mit einer Methode:

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

Nun, lassen Sie uns spielen mit es in ipython:

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

Ok, so m() irgendwie wird eine ungebundene Methode Ein.Aber ist es wirklich so?

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

Es stellt sich heraus, dass m() ist nur eine Funktion, Verweis auf die Hinzugefügt wird Ein Klasse-Wörterbuch - es gibt keine Magie.Warum dann A. m gibt uns ein ungebundenes Methode?Es ist, weil der Punkt ist nicht übersetzt zu einem einfachen Wörterbuch nachschlagen.Es ist de facto ein Aufruf 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

Nun, ich bin mir nicht sicher aus der Spitze von meinem Kopf, warum die Letzte Zeile zweimal gedruckt, aber noch ist es klar, was hier vor sich geht.

Nun, was die Standard __getattribute__ tut, ist, dass es prüft, ob das Attribut ist ein sog. descriptor oder auch nicht, d.h.wenn es implementiert einen speziellen __get__ Methode.Wenn es implementiert, die Methode, was ist dann zurückgegeben werden, ist das Ergebnis der Berufung, die __get__ Methode.Gehen wir zurück zu der ersten version unseres Ein Klasse, das ist, was wir haben:

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

Und, weil Python-Funktionen implementieren, die Deskriptor-Protokoll, wenn Sie aufgerufen werden, im Namen eines Objekts, Sie binden sich um dieses Objekt in Ihren __get__ Methode.

Ok, so wie eine Methode hinzufügen zu einem vorhandenen Objekt?Vorausgesetzt, dass Sie nicht Geist patching Klasse, es ist sehr einfach:

B.m = m

Dann B. m "wird" eine ungebundene Methode, Dank der Deskriptor Magie.

Und wenn Sie möchten, fügen Sie eine Methode hinzu, nur um ein einzelnes Objekt, dann Sie haben zu emulieren, die Maschinen selbst, durch die Verwendung von Arten.MethodType:

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

Übrigens:

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

In Python monkey-patching funktioniert im Allgemeinen durch das überschreiben einer Klasse oder Funktionen, die Signatur mit Ihrem eigenen.Unten ist ein Beispiel aus der Zope-Wiki:

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

Dieser code wird überschrieben/erstellen Sie eine Methode namens sprechen für die Klasse.In Jeff Atwood den letzten post auf monkey-patching.Er zeigt ein Beispiel in C# 3.0 ist die aktuelle Sprache, die ich für die Arbeit nutzen.

Es gibt mindestens zwei Möglichkeiten für anbringen einer Methode, um eine Instanz ohne types.MethodType:

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

Nützliche links:
Daten-Modell - aufrufen von Deskriptoren
Descriptor HowTo Guide - Aufruf Deskriptoren

Sie können lambda-so binden Sie eine Methode für eine Instanz:

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

Ausgabe:

This is instance string

Was du suchst ist setattr Glaube ich.Verwenden Sie diese, um ein Attribut auf ein Objekt.

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

Da diese Frage für nicht-Python-Versionen, hier ist das JavaScript:

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

Konsolidierung Jason Pratt ' s und dem community-wiki-Antworten mit einem Blick auf die Ergebnisse der verschiedenen Methoden der Bindung:

Vor allem beachten Sie, wie das hinzufügen die Bindung Funktion als Methode einer Klasse Werke, aber die Referenzierung Umfang ist falsch.

#!/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>>

Persönlich bevorzuge ich die externe ADDMETHOD Funktion route, so wie Sie es mir erlaubt das dynamische zuweisen von neuen Methodennamen in einen iterator als gut.

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

Ihr solltet wirklich zu schauen, verbotene Frucht, es ist eine python-Bibliothek, die Unterstützung bietet, um monkey-patching python-Klasse, auch strings.

Dies ist eigentlich ein addon, um die Antwort von "Jason Pratt"

Obwohl Jasons Antwort funktioniert, es funktioniert nur, wenn man will, eine Funktion hinzufügen, um eine Klasse.Es hat nicht funktioniert für mich, wenn ich versuchte, neu zu laden einer bereits vorhandenen Methode aus .py source-code-Datei.

Es hat mich seit Ewigkeiten einen workaround finden, aber der trick scheint einfach,...1.st importieren Sie den code aus dem source-code-Datei 2.nd force-reload 3.rd-Typen verwenden.FunctionType(...) zu konvertieren, die importiert und gebundene Methode, um eine Funktion Sie können auch auf die aktuellen globalen Variablen, wie die reloaded-Methode wäre in einem anderen namespace 4.th jetzt können Sie wie vorgeschlagen von "Jason Pratt" mit den Typen.MethodType(...)

Beispiel:

# 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

Was Jason Pratt gepostet korrekt ist.

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

Wie Sie sehen können, ist Python nicht berücksichtigen b() anders als ein().In Python sind alle Methoden sind nur Variablen, die zufällig Funktionen.

Wenn es helfen kann, habe ich kürzlich eine Python-Bibliothek namens Gorilla, um den Prozess der monkey-patching mehr bequem.

Mit einer Funktion needle() patch ein Modul mit dem Namen guineapig geht wie folgt vor:

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

Aber es kümmert sich auch um mehr interessante Anwendungsfälle, wie gezeigt, in die FAQ aus der Dokumentation.

Der code ist verfügbar auf GitHub.

Diese Frage wurde geöffnet Jahren, aber hey, es ist eine einfache Möglichkeit, zu simulieren die Bindung von einer Funktion zu einer Klasse-Instanz, die mit Dekoratoren:

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

Es, wenn Sie übergeben der Funktion und der Instanz, an die binder decorator, es wird erstellt eine neue Funktion, mit der gleichen code-Objekt wie das erste.Dann die betreffende Instanz der Klasse gespeichert ist, in ein Attribut des neu geschaffenen Funktion.Die Raumausstatter-Rückgabe eines (Dritten) - Funktion ruft automatisch die kopierte Funktion, so dass die Instanz als ersten parameter.

Abschließend erhalten Sie eine Funktion zu simulieren die Bindung an die Klasse-Instanz.Lassen Sie die ursprüngliche Funktion unverändert.

Ich finde es seltsam, dass niemand erwähnt, dass alle oben aufgeführten Methoden entsteht ein Kreislauf, den Bezug zwischen der Methode Hinzugefügt und die Instanz, sodass das Objekt persistiert werden, bis die garbage collection.Es war ein Alter trick, hinzufügen von ein Deskriptor, durch die Verlängerung der Klasse des Objekts:

def addmethod(obj, name, func):
    klass = obj.__class__
    subclass = type(klass.__name__, (klass,), {})
    setattr(subclass, name, func)
    obj.__class__ = subclass

from types import MethodType

def method(self):
   print 'hi!'


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

Mit diesem, Sie verwenden können die selbst Zeiger

Lizenziert unter: CC-BY-SA mit Zuschreibung

Nicht verbunden mit StackOverflow

Hinzufügen einer Methode zu einer Vorhandenen Objekt-Instanz

Hinzufügen einer Methode zu einer Vorhandenen Objekt-Instanz

Ja, es ist möglich, Aber nicht empfohlen

Wie kann es getan werden

Methode null (0) - verwenden Sie die Deskriptor-Methode, __get__

Methode eins - Typen.MethodType

Methode zwei:lexikalische Bindung

Methode drei:functools.teilweise

Unbound Funktion als Objekt-Attribut - warum dies nicht funktioniert:

Fazit

Dies ist eigentlich ein addon, um die Antwort von "Jason Pratt"

Methode null (0) - verwenden Sie die Deskriptor-Methode, `get`