{"id":17563,"date":"2017-06-28T16:15:12","date_gmt":"2017-06-28T13:15:12","guid":{"rendered":"http:\/\/www.webcodegeeks.com\/?p=17563"},"modified":"2018-01-09T09:37:59","modified_gmt":"2018-01-09T07:37:59","slug":"python-class-inheritance-example","status":"publish","type":"post","link":"https:\/\/www.webcodegeeks.com\/python\/python-class-inheritance-example\/","title":{"rendered":"Python Class Inheritance Example"},"content":{"rendered":"

Today we will be talking about OOP method of programming. The particular area of our interest would be Inheritance. Before we go any further, let\u2019s talk about basic principles of programming. We know that there is an imperative method (when we use for and while loops), functional (when we operate with functions) or Object Oriented Programming (where we write code using classes).
\n 
\n 
\n 
\n 
\n 
\n 
\n 
\n[ulp id=’R7QVpFMZmjosABLC’]<\/p>\n

1. Intro to Classes<\/h2>\n

We know many data structures that Python has: tuples (which are basically immutable arrays of objects), lists (same as tuples, but they are actually mutable) and dictionaries (which can be represented as hash tables). They are all good, but sometimes you need better tools to implement things you want.
\nFor example, we have a company that has different workers who hold various job positions. We can surely put all data in an array (which would take a long time), dictionary (which would be a better option, but still time-consuming) or we can just create a Class worker<\/code> with parameters explaining their job positions, work experience, salary, etc. That way, if we want to extract some information or add something new, we would operate with specific Class.
\nSo basically, Classes are structures or, in other words, skeletons of our data which we will eventually fill in. Then another question comes up, \u201cHow can we fill the structure?\u201d<\/p>\n

2. Intro to Instances<\/h2>\n

Well, we have an idea what Class is. It\u2019s a structure, showing us with what and how to fill it. If we want to fill it (which we surely do!), we need to create instances. It\u2019s a copy of class that is filled with data.
\nLet\u2019s look at the example below with workers in a company, shall we?
\nWe are creating a class called worker<\/code> with parameters name<\/code>, position<\/code>, and experience<\/code>:<\/p>\n

main.py<\/em><\/span><\/p>\n

class worker(object): \r\n\r\n   def __init__(self,name,position, experience):\r\n      self.name = name\r\n      self.position = position\r\n      self.experience = experience\r\n   def getName(self):\r\n      return self.name\r\n   def getPosition(self):\r\n      return self.experience\r\n   def getExperience(self):\r\n      return self.experience\r\n   def __str__(self):\r\n     return \"%s is %s and has been working here for the past %d years\" %(self.name, self.position, self.experience)\r\n<\/pre>\n
Line 1: We are creating the class. The word class<\/code> means that we tell Python to create a class and the word worker<\/code> is the name of it! The word object<\/code> is just a special variable that needs to be included in order to create a new class.<\/p>\n
Lines 2-5: We are creating a function by writing def<\/code>. Then we are using magic method (as known as Dunder<\/b>) called __init__<\/code>. The key idea for using it is because we are creating an instance of class firstly.
\nThe word self<\/code> is the instance of the class worker<\/code>. This is done so we can insert different data depending upon various circumstances.<\/p>\n
Lines 6-11: We are creating functions that return instances of the class. For example, the getPosition<\/code> method takes an instance of a worker<\/code> as a parameter and looks up the worker\u2019s job position. Note: we use self<\/code> to figure out the content (which can be done automatically by Python).
\nLet\u2019s create John who has worked with the company for 15 years and he is a manager:<\/p>\n
Python shell<\/em><\/span><\/p>\n
>>>  first = worker(\"John\", \"manager\", 15)<\/pre>\n
Then we will try to retrieve information about him:<\/p>\n
Python shell<\/em><\/span><\/p>\n
>>>  first = worker(\"John\", \"manager\", 15)\r\n>>>  first.getName()\r\n'John'\r\n>>>  first.getPosition()\r\n'manager'\r\n>>>  first.getExperience()\r\n15\r\n>>> print(first)\r\nJohn is manager and has been working here for the past 15 years<\/pre>\n
It works! So what we do here is every time we call methods getName<\/code>, getPosition<\/code> or getExperience<\/code> we receive information about itself.<\/p>\n
Lines 12-13: Another magic method is __str__<\/code> which defines the behavior of what will happen if we write print(Class name) <\/code>.
\nLet\u2019s try to add more workers:<\/p>\n
Python shell<\/em><\/span><\/p>\n
>>>  second = worker(\"Monica\", \"programmer\", 12)\r\n>>>  print(second)\r\nMonica is programmer and has been working here for the past 12 years\r\n>>>  third = worker(\"Jimmy\", \"programmer\", 2)\r\n>>>  print(third)\r\nJimmy is programmer and has been working here for the past 12 years\r\n>>>  fourth = worker(\"Lisa\", \"manager\", 4)\r\n>>>  print(fourth)\r\nLisa is manager and has been working here for the past 12 years<\/pre>\n
You are probably asking right now, \u201cOkay, we create classes. It\u2019s fun but wait\u2026 What if we have not 4 but 400 people in the company? We can\u2019t create instances all the time and we can\u2019t sort people like that. It\u2019s too complex!\u201d I am glad that you asked! There is another thing called subclasses<\/b>.<\/p>\n
3. Intro to subclasses<\/h2>\n
Well, maybe we have John and Lisa as managers, Monica and Jimmy as programmers. Let\u2019s create subclasses programming<\/code> and management<\/code>. Firstly, let\u2019s see what we can do with the class management<\/code>:<\/p>\n
main.py<\/em><\/span><\/p>\n
class management(worker):\r\n   def __init__(self, name, management_skills, experience):\r\n      worker.__init__(self, name, \"management\", experience)\r\n      self.management_skills = management_skills\r\n   def management_skills(self):\r\n      return self.management_skills\r\n<\/pre>\n
What we want to do here is to specify that all management<\/code> have position manager<\/code>. Since we want name, position, and experience to be initialized, we write the line 3.
\nLet\u2019s see what happen in Python shell when we find differences between worker<\/code> and management<\/code>:<\/p>\n
Python shell<\/em><\/span><\/p>\n
>>>  example_worker = worker(\"Alex\", \"programmer\", 1)\r\n>>>  example_management = management(\"Aleks\", \"manager\", 1)<\/pre>\n
What we want to check right now is whether one instance is certain class\u2019s instance. We can do it by calling isinstance()<\/code>:<\/p>\n
Python shell<\/em><\/span><\/p>\n
>>>  isinstance(example_worker, worker)\r\nTrue\r\n>>>  isinstance(example_worker, management)\r\nFalse\r\n>>>  isinstance(example_management, worker)\r\nTrue\r\n>>>  isinstance(example_management, management)\r\nTrue<\/pre>\n
One thing may seem confusing to you right now, \u201cWhy is example_management<\/code> and worker<\/code> returns true?\u201d. That\u2019s a very good question! Since management is worker\u2019s subclass, it inherits attributes of it. In other words, worker is a base for management, so every time we check for worker as a second parameter, we get True<\/code>. But we can only get True<\/code> while calling for management if we are calling the very same subclass (which is the last line of the code above).<\/p>\n
4. Summary<\/h2>\n
In the example above we saw multiple things:<\/p>\n