Unbound methods and Static methods
Methods that do not have an instance of the class as the first argument are known as unbound methods. As of Python 3.0, the unbound methods have been removed from the language. They are not bounded with any specific object of the class. To make the method myFunc2() work in the above class it should be made into a static method
Static methods are similar to class methods but are bound completely to class instead of particular objects. They are accessed using class names.
Need for making a method static
Not all the methods need to alter the instances of a class. They might serve any common purpose. A method may be a utility function also.
For example, When we need to use certain mathematical functions, we use the built in class Math
. The methods in this class are made static because they have nothing to do with specific objects. They do common actions. Thus each time it is not an optimized way to write as:
math=Math() math.ceil(5.23)
So they can be simply accessed using their class name as Math.ceil(5.23)
.
A method can be made static in two ways:
- Using staticmethod()
- Using decorator
Using staticmethod(): The staticmethod()
function takes the function to be converted as its argument and returns the static version of that function. A static function knows nothing about the class, it just works with the parameters passed to it.
Example:
class sample(): def myFunc2(x): print ( "I am" , x, "from the static method" ) sample.myFunc2 = staticmethod (sample.myFunc2) sample.myFunc2( "A" ) |
Output:
I am A from the static method
Using decorators: These are features of Python used for modifying one part of the program using another part of the program at the time of compilation. The decorator that can be used to make a method static is
@staticmethod
This informs the built-in default metaclass not to create any bound methods for this method. Once this line is added before a function, the function can be called using the class name. Consider the example taken for the Bound method where we encountered an error. To overcome that, it can be written as:
class sample( object ): # Static variable for object number objectNo = 0 def __init__( self , name1): # variable to hold name self .name = name1 # Increment static variable for each object sample.objectNo = sample.objectNo + 1 # each object's unique number that can be # considered as ID self .objNumber = sample.objectNo def myFunc( self ): print ( "My name is " , self .name, "from object " , self .objNumber) def alterIt( self , newName): self .name = newName # using decorator to make the method static @staticmethod def myFunc2(): print ( "I am not a bound method !!!" ) # creating first instance of class sample samp1 = sample( "A" ) samp1.myFunc() sample.myFunc2() #----------> error line # creating second instance of class sample samp2 = sample( "B" ) samp2.myFunc() samp2.alterIt( "C" ) samp2.myFunc() samp1.myFunc() |
Output:
My name is A from object 1 I am not a bound method !!! My name is B from object 2 My name is C from object 2 My name is A from object 1
Here, the line sample.myFunc2() runs without any error and the print() within it works perfectly and gives the output I am not a bound method!!!
Bound, unbound, and static methods in Python
Methods in Python are like functions except that it is attached to an object.The methods are called on objects and it possibly make changes to that object. These methods can be Bound, Unbound or Static method. The static methods are one of the types of Unbound method. These types are explained in detail below.
Contact Us