CODEWITHSUNDEEP
python
Jack_of_All_Trades
Jack_of_All_Trades

Reputation: 11488

Using class methods as simple functions

I have a class with many methods. How can I modify my methods so that they can also be accessed directly as a function without creating object of that class? Is it possible.

Upvotes: 2

Views: 143

Answers (3)

Yatharth Agarwal
Yatharth Agarwal

Reputation: 4564

Unbound Methods

To create an unbound method (i.e., its first variable is'nt self), you can decorate the method using the @staticmethod built-in decorator. If decorators or any of that is not making sense, check out the Wiki, this simple explanation, decorators as syntactic sugar and learn how to write a good one.

>>> class foo(object):
...     @staticmethod
...     def bar(blah_text):
...         print "Unbound method `bar` of Class `foo`"
...         return blah_text 
...     
>>> foobar = foo.bar
>>> foobar("We are the Knights who say 'Ni'!")
Unbound method `bar` of Class `foo`
"We are the Knights who say 'Ni'!"

Bound Methods

These methods are not technically 'bound', but are meant to be binded when called. You just have to point a reference to them and "Wala", you now have a reference to that method. Now you just have to pass a valid instance of that Class:

>>> class foo:
...     def __init__(self, bar_value = 'bar'):
 ...         self.bar_value = bar_value
...     def bar(self, blah_text):    
...         return self.bar_value + blah_text
...         
>>> bar = foo.bar
>>> bar(foo('We are the Knights who say '), "'Ni'")
"We are the Knights who say 'Ni'"

Edit: As is pointed out in the comments, it seems my usage of 'binding' is wrong. Could somebody with knowledge of it edit/correct my post?

Upvotes: 1

bukzor
bukzor

Reputation: 38532

The methods will be "unbound" (meaning, essentially, that they have no self to work with). If the functions do not operate upon self, you can turn them into static-methods (which do not take a self first argument) and then assign them to variables to be used like functions.

Like so:

class MyClass(object):
    @staticmethod
    def myfunc():
        return "It works!"

myfunc = MyClass.myfunc

myfunc() # prints "It works!"

Essentially, you need to ask yourself "What data does my method need to (er) function?" Depending on your answer, you can use @staticmethod or @classmethod or you may find that you do in fact need a self in which case you will need to create an object before trying to use its methods.

That final case would look something like:

myobj = MyClass()
del MyClass # This is a singleton class
myfunc = myobj.myfunc

All of that aside, if you find that all of your methods are actually staticmethods, then it's better style to refactor them out of the class into plain-old functions, which they really are already. You may have learned this "class as namespace" style from Java, but that isn't correct in Python. Python namespaces are represented by modules.

Upvotes: 6

KDavid
KDavid

Reputation: 175

You can call the function with the class name as a parameter, if you do not want to lose self:

class something:
    def test(self):
        print('Hello')

something.test(something)
#prints "Hello"

Upvotes: -1

Related Questions