This section of our beginning python training class always stumps students.  Firstly, because they need to know the difference between a function and a method.  Secondly, they need to understand object oriented programming concepts.  Thirdly, they need to realize that python has three types of methods.  Then they need to know how to use each method, which means they need to know the purpose of each method type.  Then they have to understand mutable versus non-mutable types.  The list goes on.  As part of our python tutorial, I hope to shed some light on this confusing topic.

To begin, the difference between a function and a method in python is that a method is defined within a class.  Here is an illustration:

Teaching You Tools to Become Empowered

To build a successful business and career, you must always keep up with changes in the IT Marketplace. AWS, Office 365, LinkedIn, Sales Force, SEO, Social Media are just a few examples of where knowledge is a huge factor for success.

Training with HSG addresses your knowledge gaps and provides you with the requisite tools to outpace the competition.

#function

	def greeting():
	                print "Hello, I hope you're having a great day!"

	class HSGPrinter(object):
	                #method
	                def greeting(self): 
	                                print "Hello, I hope you're having a great day!"

As should be obvious, the second definition of greeting is encapsulated within the HSGPrinter class and is , therefore, refered to as a method.

The astute reader will notice that the greeting method contains one parameter named self.  For those who know C++ , Java or C#, self is equivalent to this i.e. it is a reference to the invoking object:

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', 'Lexmark']