python OOP

akashtalole · akashtalole · commit 22486fe59735 · 2019-09-20T11:32:14.000+05:30
diff --git a/docs/index.md b/docs/index.md
@@ -1044,4 +1044,197 @@ Data storage applications.
 
 - What are security concerns related to IoT?
 
-- This is the common IoT Interview Questions asked in an interview. Data security and privacy are major concerns related to IoT. These devices are vulnerable to hacking and cloud endpoints could be used by hackers to attack servers. Software developers and device designers have to ensure adequate security and privacy measures.
+- This is the common IoT Interview Questions asked in an interview. Data security and privacy are major concerns related to IoT. These devices are vulnerable to hacking and cloud endpoints could be used by hackers to attack servers. Software developers and device designers have to ensure adequate security and privacy measures.
+
+# Python Object Oriented Programming(OOP)
+
+Python is a multi-paradigm programming language. Meaning, it supports different programming approach.
+
+One of the popular approach to solve a programming problem is by creating objects. This is known as Object-Oriented Programming (OOP).
+
+An object has two characteristics:
+
+attributes
+behavior
+Let's take an example:
+
+Parrot is an object,
+
+name, age, color are attributes
+singing, dancing are behavior
+The concept of OOP in Python focuses on creating reusable code. This concept is also known as DRY (Don't Repeat Yourself).
+
+In Python, the concept of OOP follows some basic principles:
+
+- Inheritance	A process of using details from a new class without modifying existing class.
+- Encapsulation	Hiding the private details of a class from other objects.
+- Polymorphism	A concept of using common operation in different ways for different data input.
+
+- Class
+A class is a blueprint for the object.
+
+We can think of class as an sketch of a parrot with labels. It contains all the details about the name, colors, size etc. Based on these descriptions, we can study about the parrot. Here, parrot is an object.
+
+The example for class of parrot can be :
+```
+class Parrot:
+    pass
+```
+Here, we use class keyword to define an empty class Parrot. From class, we construct instances. An instance is a specific object created from a particular class.
+
+- Object
+An object (instance) is an instantiation of a class. When class is defined, only the description for the object is defined. Therefore, no memory or storage is allocated.
+
+The example for object of parrot class can be:
+```
+obj = Parrot()
+```
+Here, obj is object of class Parrot.
+
+Suppose we have details of parrot. Now, we are going to show how to build the class and objects of parrot.
+```
+class Parrot:
+
+    # class attribute
+    species = "bird"
+
+    # instance attribute
+    def __init__(self, name, age):
+        self.name = name
+        self.age = age
+
+# instantiate the Parrot class
+blu = Parrot("Blu", 10)
+woo = Parrot("Woo", 15)
+
+# access the class attributes
+print("Blu is a {}".format(blu.__class__.species))
+print("Woo is also a {}".format(woo.__class__.species))
+
+# access the instance attributes
+print("{} is {} years old".format( blu.name, blu.age))
+print("{} is {} years old".format( woo.name, woo.age))
+```
+
+- Methods
+Methods are functions defined inside the body of a class. They are used to define the behaviors of an object.
+```
+class Parrot:
+    
+    # instance attributes
+    def __init__(self, name, age):
+        self.name = name
+        self.age = age
+    
+    # instance method
+    def sing(self, song):
+        return "{} sings {}".format(self.name, song)
+
+    def dance(self):
+        return "{} is now dancing".format(self.name)
+
+# instantiate the object
+blu = Parrot("Blu", 10)
+
+# call our instance methods
+print(blu.sing("'Happy'"))
+print(blu.dance())
+```
+
+- Inheritance
+Inheritance is a way of creating new class for using details of existing class without modifying it. The newly formed class is a derived class (or child class). Similarly, the existing class is a base class (or parent class).
+
+```
+# parent class
+class Bird:
+    
+    def __init__(self):
+        print("Bird is ready")
+
+    def whoisThis(self):
+        print("Bird")
+
+    def swim(self):
+        print("Swim faster")
+
+# child class
+class Penguin(Bird):
+
+    def __init__(self):
+        # call super() function
+        super().__init__()
+        print("Penguin is ready")
+
+    def whoisThis(self):
+        print("Penguin")
+
+    def run(self):
+        print("Run faster")
+
+peggy = Penguin()
+peggy.whoisThis()
+peggy.swim()
+peggy.run()
+```
+
+- Encapsulation
+Using OOP in Python, we can restrict access to methods and variables. This prevent data from direct modification which is called encapsulation. In Python, we denote private attribute using underscore as prefix i.e single "_ "or double "__".
+
+```
+class Computer:
+
+    def __init__(self):
+        self.__maxprice = 900
+
+    def sell(self):
+        print("Selling Price: {}".format(self.__maxprice))
+
+    def setMaxPrice(self, price):
+        self.__maxprice = price
+
+c = Computer()
+c.sell()
+
+# change the price
+c.__maxprice = 1000
+c.sell()
+
+# using setter function
+c.setMaxPrice(1000)
+c.sell()
+```
+
+- Polymorphism
+Polymorphism is an ability (in OOP) to use common interface for multiple form (data types).
+
+Suppose, we need to color a shape, there are multiple shape option (rectangle, square, circle). However we could use same method to color any shape. This concept is called Polymorphism.
+
+```
+class Parrot:
+
+    def fly(self):
+        print("Parrot can fly")
+    
+    def swim(self):
+        print("Parrot can't swim")
+
+class Penguin:
+
+    def fly(self):
+        print("Penguin can't fly")
+    
+    def swim(self):
+        print("Penguin can swim")
+
+# common interface
+def flying_test(bird):
+    bird.fly()
+
+#instantiate objects
+blu = Parrot()
+peggy = Penguin()
+
+# passing the object
+flying_test(blu)
+flying_test(peggy)
+```
