Ajout d'une Méthode à une Instance d'Objet

En Python, il y a une différence entre les fonctions et les méthodes liées.

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

Lié méthodes ont été "lié" (comment descriptive) à une instance, qui sera passé comme premier argument à chaque fois que la méthode est appelée.

Callables qui sont des attributs d'une classe (par opposition à une instance) sont encore indépendant, cependant, de sorte que vous pouvez modifier la définition de la classe à chaque fois que vous voulez:

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

Défini précédemment instances sont mises à jour (tant qu'ils n'ont pas remplacé l'attribut eux-mêmes):

>>> a.fooFighters()
fooFighters

Le problème vient quand vous voulez joindre une méthode à une seule instance:

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

La fonction n'est pas automatiquement lié quand il est connecté directement à une instance:

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

À la lie, nous pouvons utiliser la MethodType fonction des types de module:

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

Ce temps, les autres instances de la classe n'ont pas été touchés:

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

Plus d'informations peuvent être trouvées par la lecture sur les les descripteurs de et métaclasse programmation.

Préface - une note sur la compatibilité: autres réponses ne peuvent travailler en Python 2 - cette réponse devrait fonctionner parfaitement en Python 2 et 3. Si l'écriture de Python 3 seulement, vous pouvez laisser explicitement l'héritage de object, mais sinon, le code doit rester le même.

L'ajout d'une Méthode à un Objet Existant Instance

J'ai lu qu'il est possible d'ajouter une méthode à un objet existant (par exemple, pas dans la définition de la classe) en Python.

Je comprends que ce n'est pas toujours une bonne décision de le faire. Mais, comment peut-on faire cela?

Oui, c'est possible, Mais pas recommandé

Je ne le recommande pas. C'est une mauvaise idée. Ne pas le faire.

Voici un couple de raisons:

• Vous allez ajouter un objet lié à chaque instance, vous faites cela pour. Si vous faites cela, vous aurez probablement perdre beaucoup de mémoire. Les méthodes liées sont généralement créés uniquement pour la courte durée de leur appel, et ensuite, ils cessent d'exister lorsque automatiquement les ordures collectées. Si vous le faites manuellement, vous aurez un nom de liaison de référencement lié à la méthode d'empêcher son la collecte des ordures sur l'utilisation.
• Des instances d'objets d'un type donné, ont généralement ses méthodes sur tous les objets de ce type. Si vous ajoutez des méthodes d'ailleurs, certains des instances de ces méthodes et d'autres pas. Les programmeurs ne s'attend pas à cela, et vous le risque de violation du la règle de moindre surprise.
• Depuis il y a d'autres très bonnes raisons de ne pas faire cela, vous aurez en plus de vous donner une mauvaise réputation si vous le faites.

Donc, je vous suggère de ne pas le faire, sauf si vous avez une très bonne raison. Il est de loin préférable de définir la méthode correcte dans la définition de classe ou moins, de préférence, de singe-patch dans la classe, comme ceci:

Foo.sample_method = sample_method

Puisque c'est instructif, cependant, je vais vous montrer quelques façons de le faire.

Comment il peut être fait

Voici quelques code d'installation. Nous avons besoin d'une définition de classe. Il pourrait être importés, mais il n'a vraiment pas d'importance.

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

Créer une instance:

foo = Foo()

Créer une méthode pour ajouter:

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

Méthode de zéro (0) - utiliser le descripteur de la méthode, __get__

En pointillés recherches sur les fonctions d'appel de la __get__ méthode de la fonction de l'instance, la liaison de l'objet de la méthode et donc de la création d'une "méthode liée."

foo.sample_method = sample_method.__get__(foo)

et maintenant:

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

De la méthode des types.MethodType

D'abord, l'importation de types, à partir de laquelle nous allons obtenir la méthode constructeur:

import types

Maintenant, nous ajoutons la méthode de l'instance. Pour ce faire, nous avons besoin de la MethodType constructeur de la types module (qui nous avons importé ci-dessus).

L'argument de signature pour les types.MethodType est (function, instance, class):

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

et utilisation:

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

Méthode deux: lexical de liaison

Tout d'abord, nous créons une fonction wrapper qui lie la méthode de l'instance:

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

utilisation:

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

Méthode trois: functools.partielle

Une fonction partielle s'applique le premier argument(s) à une fonction (et éventuellement les arguments mots-clefs), et peuvent plus tard être appelé avec les autres arguments (et en remplaçant les arguments mots-clefs). Donc:

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

Cela fait sens quand on considère que les méthodes liées sont partielles des fonctions de l'instance.

Indépendant fonctionner comme un attribut de l'objet - pourquoi cela ne fonctionne pas:

Si nous essayons d'ajouter à la sample_method de la même façon que nous puissions l'ajouter à la classe, il est indépendant de l'instance, et ne prend pas l'implicite de soi en tant que premier 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)

Nous pouvons le rendre indépendant de la fonction de travail en faisant explicitement en passant l'instance (ou quoi que ce soit, étant donné que cette méthode n'est pas réellement utiliser le self argument variable), mais il ne serait pas cohérent avec la signature attendue de d'autres instances (si nous sommes singe de correction de cette instance):

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

Conclusion

Vous savez maintenant plusieurs façons de pourrait le faire, mais en toute sincérité, - ne pas le faire.

En Python monkey patching fonctionne généralement à l'écrasement d'une classe ou d'une des fonctions de signature avec votre propre. Ci-dessous est un exemple de la Zope Wiki:

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

Que le code s'écraser/créer une méthode appelée parler à la classe. Dans Jeff Atwood est post récent sur monkey patching. Il montre un exemple en C# 3.0, ce qui est la langue que j'utilise pour le travail.

Il y a au moins deux façons de fixer une méthode d'une instance sans 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>

1:

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

2:

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

Liens utiles:

Modèle de données d'invocation des descripteurs

Descripteur HowTo Guide d'invocation des descripteurs

Depuis cette question posée pour les non-versions de Python, voici JavaScript:

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

C'est en fait un addon pour la réponse de "Jason Pratt"

Bien que Jasons réponse fonctionne, il fonctionne seulement si l'on veut ajouter une fonction à une classe.
Il ne fonctionne pas pour moi quand j'ai essayé de recharger une méthode déjà existante de la .py fichier de code source.

Il m'a fallu pour les âges à trouver une solution de contournement, mais le truc semble simple...
1.st importer le code à partir du fichier de code source
2.nd forcer un rechargement
3.rd types d'utilisation.FunctionType(...) pour convertir l'importés et de la méthode liée à une fonction
vous pouvez également passer sur le courant des variables globales, comme le reloaded méthode serait dans un espace de noms différent
4.th maintenant, vous pouvez continuer comme suggéré par "Jason Pratt"
en utilisant les types.MethodType(...)

Exemple:

# 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

Si elle peut être d'une aide quelconque, j'ai récemment publié une bibliothèque Python nommé Gorille à rendre le processus de monkey patching plus pratique.

À l'aide d'une fonction needle() pour patch un module nommé guineapig va comme suit:

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

Mais il s'occupe aussi de plus intéressant cas d'utilisation comme indiqué dans le FAQ de la la documentation.

Le code est disponible sur GitHub.

Je trouve étrange que personne n'a mentionné que toutes les méthodes énumérées ci-dessus crée un cycle de référence entre l'ajout de la méthode et de l'instance, provoquant l'objet persistant jusqu'à la collecte des ordures. Il y avait un vieux truc de l'ajout d'un descripteur par l'extension de la classe de l'objet:

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