Python Tutorial - Static, Class and Regular Methods:
:
hsgPrinter = HSGPrinter()
hsgPrinter.greeting()
Here hsgPrinter is the invoking object and, therefore, equivalent to self.
Now that we know the difference between a function and a method, let's focus on method types. The defined method is known as a regular or instance method because it contains a reference to self. Static and class methods do not contain this parameter. Moreover, they must be registered with the python runtime engine as such types. Here is the way it's done:
class HSGPrinter(object): count = 1 printertypes = ['HP','Canon'] #regular method def regularCounter(self): self.count = 4 print self.count self.printertypes.append('Lexmark') self.printertypes = ['Laser','Color'] print HSGPrinter.printertypes #class method def clsCounter(cls): cls.count = cls.count+1 print cls.count print HSGPrinter.printertypes clsCounter = classmethod(clsCounter) #static method def staticCounter(): print HSGPrinter.count print HSGPrinter.printertypes staticCounter = staticmethod(staticCounter) printer = HSGPrinter() printer.clsCounter() printer.regularCounter() printer.staticCounter()
Here is the outcome when running this module:
2
['HP', 'Canon']
4
['HP', 'Canon', 'Lexmark']
2
['HP', 'Canon', 'Lexmark']
The three methods from the example above are as follows:
1. regularCounter - regular method
a. has a self parameter
b. not registered with the python runtime engine in any special way
2. classCounter - class method
a. has a cls parameter which refers to the class itself. Used to access class variables
b. registered with the python runtime engine via the classmethod function
3. staticCounter - static method
a. contains no self or cls parameter
b. registered with the python runtime engine via the staticmethod function
When to use or create which method:
Regular methods are used to update and/or create object attributes or instance variables. This is accomplished using self as in self.count = 4. Remember that each object can have its own variables as opposed to class variables which are values common to all objects of a class. That is, a class variable is a variable that is referrenced by all objects such that the update of that variable is reflected to each object.
Class methods are used to handle class variables. They do not reguire the instantiation of an object to be invoked. Invocation of these methods is achieved by the class name preceding the class method name as in HSGPrinter.classCounter(). As a convenience, access to the class variables via these methods is accomplished by use of the cls or class parameter passed to this method as in cls.count.
Static methods have nothing to do with a class whatsoever. They are methods that are suited to replace functions which are seen in the object oriented programming world as dangling code. It is far more efficient and understandable to associate functionality with a class than with a function. Take for example a Math class, none of the methods should be regular methods because they require the instantiantion of an object. It is poor design to create a Math object in order to sum twon or more numbers. Moreover, there is hardly any reason to create class methods; other than say PI or E, how many other class variables are needed. The bulk of these methods should be static methods which may or may not need to access class variables and to whom are passed the requisite values to complete the computation. Such methods may be the cos, sign, arctan, addition, remainder ...
Here is the outcome of running the module above. Notice how the class variable is not modified by the expression self.count = 4. This variable only updates the objects count value and not the class' count value. Also, notice how the class variable printertypes is modified by the expression self.printertypes.append('Lexmark'). Why do you suppose this happened?
When modifying class variables that are mutable types, such as list, a new variable is not created as occured when changing a non-mutable number variable like count. Therefore, when writing self.count = 4, a new count variable is created for each object. On the other hand, when writing self.printertypes.append(...), the orginal class variable is modified instead of creating a printertypes variable for each object.
What happens in the following situation: self.printertypes = ['Laser','Color']? If you guessed that an object attribute or instance variable is created, you are correct. The class variable, printertypes, still exists, but each object also has its own such printertypes variable.
Access to each type is visible in the method shown here:
def printPrintertypes(self): print self.printertypes #object attribute print HSGPrinter.printertypes
Here is the outcome when running the method above:
['Laser', 'Color']
['HP', 'Canon', 'Lex