While it’s not strictly possible to do, as rightly pointed out, you could always “fake” it by redefining the method on instantiation, like this:

class YourClass(object):

    def __init__(self):
        self.foo = self._instance_foo

    @staticmethod
    def foo():
        print "Static!"

    def _instance_foo(self):
        print "Instance!"

which would produce the desired result:

>>> YourClass.foo()
Static!
>>> your_instance = YourClass()
>>> your_instance.foo()
Instance!

A similar question is here: override methods with same name in python programming

functions are looked up by name, so you are just redefining foo with an instance method. There is no such thing as an overloaded function in Python. You either write a new function with a separate name, or you provide the arguments in such a way that it can handle the logic for both.

In other words, you can’t have a static version and an instance version of the same name. If you look at its vars you’ll see one foo.

In [1]: class Test:
   ...:     @staticmethod
   ...:     def foo():
   ...:         print 'static'
   ...:     def foo(self):
   ...:         print 'instance'
   ...:         

In [2]: t = Test()

In [3]: t.foo()
instance

In [6]: vars(Test)
Out[6]: {'__doc__': None, '__module__': '__main__', 'foo': <function __main__.foo>}

Because attribute lookup in Python is something within the programmer’s control, this sort of thing is technically possible. If you put any value into writing code in a “pythonic” way (using the preferred conventions and idioms of the python community), it is very likely the wrong way to frame a problem / design. But if you know how descriptors can allow you to control attribute lookup, and how functions become bound functions (hint: functions are descriptors), you can accomplish code that is roughly what you want.

For a given name, there is only one object that will be looked up on a class, regardless of whether you are looking the name up on an instance of the class, or the class itself. Thus, the thing that you’re looking up has to deal with the two cases, and dispatch appropriately.

(Note: this isn’t exactly true; if an instance has a name in its attribute namespace that collides with one in the namespace of its class, the value on the instance will win in some circumstances. But even in those circumstances, it won’t become a “bound method” in the way that you probably would wish it to.)

I don’t recommend designing your program using a technique such as this, but the following will do roughly what you asked. Understanding how this works requires a relatively deep understanding of python as a language.

class StaticOrInstanceDescriptor(object):

    def __get__(self, cls, inst):
        if cls is None:
            return self.instance.__get__(self)
        else:
            return self.static

    def __init__(self, static):
        self.static = static

    def instance(self, instance):
        self.instance = instance
        return self


class MyClass(object):

    @StaticOrInstanceDescriptor
    def foo():
        return 'static method'

    @foo.instance
    def foo(self):
        return 'public method'

obj = MyClass()
print(obj.foo())
print(MyClass.foo())

which does print out:

% python /tmp/sandbox.py
static method
public method

Ended up here from google so thought I would post my solution to this “problem”…

class Test():
    def test_method(self=None):
        if self is None:
            print("static bit")
        else:
            print("instance bit")

This way you can use the method like a static method or like an instance method.

When you try to call MyClass.foo(), Python will complain since you did not pass the one required self argument. @coderpatros’s answer has the right idea, where we provide a default value for self, so its no longer required. However, that won’t work if there are additional arguments besides self. Here’s a function that can handle almost all types of method signatures:

import inspect
from functools import wraps

def class_overload(cls, methods):
    """ Add classmethod overloads to one or more instance methods """
    for name in methods:
        func = getattr(cls, name)
        # required positional arguments
        pos_args = 1 # start at one, as we assume "self" is positional_only
        kwd_args = [] # [name:str, ...]
        sig = iter(inspect.signature(func).parameters.values())
        next(sig)
        for s in sig:
            if s.default is s.empty:
                if s.kind == s.POSITIONAL_ONLY:
                    pos_args += 1
                    continue
                elif s.kind == s.POSITIONAL_OR_KEYWORD:
                    kwd_args.append(s.name)
                    continue
            break
        @wraps(func)
        def overloaded(*args, **kwargs):
            # most common case: missing positional arg or 1st arg is not a cls instance
            isclass = len(args) < pos_args or not isinstance(args[0], cls)
            # handle ambiguous signatures, func(self, arg:cls, *args, **kwargs);
            # check if missing required positional_or_keyword arg
            if not isclass:
                for i in range(len(args)-pos_args,len(kwd_args)):
                    if kwd_args[i] not in kwargs:
                        isclass = True
                        break
            # class method
            if isclass:
                return func(cls, *args, **kwargs)
            # instance method
            return func(*args, **kwargs)
        setattr(cls, name, overloaded)

class Foo:
    def foo(self, *args, **kwargs):
        isclass = self is Foo
        print("foo {} method called".format(["instance","class"][isclass]))

class_overload(Foo, ["foo"])

Foo.foo() # "foo class method called"
Foo().foo() # "foo instance method called"

You can use the isclass bool to implement the different logic for class vs instance method.

The class_overload function is a bit beefy and will need to inspect the signature when the class is declared. But the actual logic in the runtime decorator (overloaded) should be quite fast.

There’s one signature that this solution won’t work for: a method with an optional, first, positional argument of type Foo. It’s impossible to tell if we are calling the static or instance method just by the signature in this case. For example:

def bad_foo(self, other:Foo=None):
    ...
bad_foo(f) # f.bad_foo(None) or Foo.bad_foo(f) ???

Note, this solution may also report an incorrect isclass value if you pass in incorrect arguments to the method (a programmer error, so may not be important to you).

We can get a possibly more robust solution by doing the reverse of this: first start with a classmethod, and then create an instance method overload of it. This is essentially the same idea as @Dologan’s answer, though I think mine is a little less boilerplatey if you need to do this on several methods:

from types import MethodType

def instance_overload(self, methods):
    """ Adds instance overloads for one or more classmethods"""
    for name in methods:
        setattr(self, name, MethodType(getattr(self, name).__func__, self))

class Foo:
    def __init__(self):
        instance_overload(self, ["foo"])

    @classmethod
    def foo(self, *args, **kwargs):
        isclass = self is Foo
        print("foo {} method called:".format(["instance","class"][isclass]))

Foo.foo() # "foo class method called"
Foo().foo() # "foo instance method called"

Not counting the code for class_overload or instance_overload, the code is equally succinct. Often signature introspection is touted as the “pythonic” way to do these kinds of things. But I think I’d recommend using the instance_method solution instead; isclass will be correct for any method signature, including cases where you call with incorrect arguments (a programmer error).