Difference between class and instance methods

by

Instance methods

When creating an instance method, the first parameter is always self.
You can name it anything you want, but the meaning will always be the same, and you should use self since it’s the naming convention.
self is (usually) passed hiddenly when calling an instance method; it represents the instance calling the method.

Here’s an example of a class called Inst that has an instance method called introduce():

class Inst:

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

    def introduce(self):
        print("Hello, I am %s, and my name is " %(self, self.name))

Now to call this method, we first need to create an instance of our class.
Once we have an instance, we can call introduce() on it, and the instance will automatically be passed as self:

myinst = Inst("Test Instance")
otherinst = Inst("An other instance")
myinst.introduce()
# outputs: Hello, I am <Inst object at x>, and my name is Test Instance
otherinst.introduce()
# outputs: Hello, I am <Inst object at y>, and my name is An other instance

As you see, we’re not passing the parameter self. It gets hiddenly passed with the period operator. We’re calling Inst class’s instance method introduce, with the parameter of myinst or otherinst.
This means that we can call Inst.introduce(myinst) and get the exact same result.

Class methods

The idea of a class method is very similar to an instance method, only difference being that instead of passing the instance hiddenly as a first parameter, we’re now passing the class itself as a first parameter.

class Cls:

    @classmethod
    def introduce(cls):
        print("Hello, I am %s!" %cls)

Since we’re passing only a class to the method, no instance is involved.

This means that we don’t need an instance at all, and we call the class method as if it was a static function:

 Cls.introduce() # same as Cls.introduce(Cls)
 # outputs: Hello, I am <class 'Cls'>

Notice that again Cls is passed hiddenly, so we could also say Cls.introduce(Inst) and get output "Hello, I am <class 'Inst'>.

This is particularly useful when we’re inheriting a class from Cls:

class SubCls(Cls):
    pass

SubCls.introduce()
# outputs: Hello, I am <class 'SubCls'>

More Related Contents:

  1. Short description of the scoping rules?
  2. Handling very large numbers in Python
  3. Why do you need explicitly have the “self” argument in a Python method?
  4. How do I get monitor resolution in Python?
  5. Size of list in memory
  6. What are iterator, iterable, and iteration?
  7. pycharm doesn’t recognize pygame package
  8. How to find duplicate elements in array using for loop in Python?
  9. Accessing a value in a tuple that is in a list
  10. What’s the best way to get an HTTP response code from a URL?
  11. Why does x,y = zip(*zip(a,b)) work in Python?
  12. faster alternative to numpy.where?
  13. Networkx: Overlapping edges when visualizing MultiGraph
  14. How to calculate the statistics “t-test” with numpy
  15. How to filter a pandas dataframe based on the length of a entry
  16. How can I group a stacked bar chart?
  17. Check if a given key already exists in a dictionary and increment it
  18. What’s the difference between subprocess Popen and call (how can I use them)?
  19. Performance of zeros function in Numpy
  20. How can I render a tree structure (recursive) using a django template?
  21. Clear text from textarea with selenium
  22. How to specify credentials when connecting to boto3 S3?
  23. Clear valid form after it is submitted
  24. Submitting to a web form using python
  25. Python Append to a list returns none [duplicate]
  26. Installing Python-2.7 on Ubuntu 10.4
  27. Data tooltips in Bokeh don’t show data, showing ‘???’ instead
  28. A more pythonic way to define an enum with dynamic members
  29. How to handle the popup “Accepting all cookies” when the element is data-testid – Using Selenium in Python
  30. Python BeautifulSoup give multiple tags to findAll

Leave a Comment