override method of class in python

I'd like to override a class method, not creating subclass/extending from a class.

An example:

from django.contrib import admin

cla开发者_StackOverflowss NewModelAdmin(admin.ModelAdmin):
    def formfield_for_dbfield(self, db_field, **kwargs):
        # some custom stuff

Now I don't want to change all the classes (aka Models) which extend from admin.ModelAdmin to NewModelAdmin. But I don't want to modify the original django code either.

Is there some way to accomplish this?

I'm not 100% clear with what you want to do, and why you don't want to create a new subclass or have a method of a different name.

But in general in python you can do something like:

class MyClass(object):
    def print_hello(self):
        print "not hello"

def real_print_hello():
    print "hello"

x = MyClass()
x.print_hello() # "not hello"
setattr(x, "print_hello", real_print_hello)
x.print_hello() # "hello"

Are you trying to do 'monkey patching'?

http://mail.python.org/pipermail/python-dev/2008-January/076194.html

In order to keep your code maintainable, it's best to go ahead and have your individual ModelAdmin classes inherit from NewModelAdmin. This way, other developers who look at your code (and you, perhaps a year or two later) can clearly see where the custom formfield_for_dbfield behavior originates from so that it can be updated if needed. If you monkey-patch admin.ModelAdmin, it will make it much more difficult to track down issues or change the behavior if needed later.

Chances are good that your problem is solvable without monkey-patching, which often can have unintended consequences.

How are you registering models with the django admin?

If you are using this approach:

admin.site.register(FooModel) #uses generic ModelAdmin

You have the problem of needing to change this to many boilerplate instances of subclasses of NewModelAdmin, which would look like this:

class FooModelAdmin(NewModelAdmin):
    pass #does nothing except set up inheritance
admin.site.register(FooModel, FooModelAdmin)

This is really wordy and might take a lot of time to implement if you have a lot of models, so do it programmatically by writing a wrapper function:

def my_admin_register(model):
    class _newmodeladmin(ModelAdmin):
        def your_overridden_method(*args, **kwargs):
            #do whatever here
    admin.site.register(model, _newmodeladmin)

Then, you can use this like this:

my_admin_register(FooModel)

You can change a class method using setattr() on the class - aka monkey patching.

If you modify a method in a class you modify behavior for:

• all instances which resolve their method to that class
• all derived classes which resolve their method to that class

Your requirements are mutually exclusive. You cannot modify the behavior of a class without impacting those object which resolve their methods to the class.

In order to not modify the behaviors of these other objects you would want to create the method in your instance so that it doesn't resolve it's method in the class.

Another alternative is to rely on Python's duck-typing. You don't need the object to be directly related to the one currently used. You could reimplement the interface and in the code swap out the calls to the old class for your new one.

These techniques have tradeoffs in maintainability and design. In other words don't use them unless you have no other options.

I'm not 100% sure what you are trying to achieve, but I suppose you want to behave all admins that inherit from models.ModelAdmin without having to change their declaration. The only solution to achieve this will be monkey-patching the original ModelAdmin class, eg. something like:

setattr(admin.ModelAdmin, 'form_field_for_dbfield', mymethod)

This for sure not the most recommendable way, because the code will be hard to maintain and other things.