Is Python Object Oriented?

This article will describe whether Python is Object Oriented or not. You will get to know about the OOPS concepts used in Python with details.

Introduction

 
Languages that use objects in programming are called Object Oriented Programming. Everything in Python is an Object.
 
Object is an abstract data type. An object has two characteristics:
  • Attributes
  • Behaviour
Let us take an example, Child is an object. Its characteristics are: Name, Age, Blood Group, Caste etc. Attributes are: Crying, Dancing, Playing, Studying etc. (Behaviour)
 

Oops Concepts in Python

Class

 
The class is a blueprint that defines a nature of a future object. A class is collection of objects
  1. class MyClass(): //Creating a class    
  2.   "This is a DocString"  
  3. x = 5  
  4.   
  5. MyClass = MyClass()  
  6. print(MyClass)  // output: __main__.MyClass object at 0x00000138B2138508>    
  7. print(MyClass.x)  // output: 5    
  8. print(MyClass.__doc__)  //output: This is a DocString 

Object

 
An instance is a specific object created from a particular class.
    1. class MyClass():  
    2.   x = 5  
    3. def myFunction():  
    4.   print('Hello')  
    5.   
    6. my_object = MyClass() //Creating an object of a class    
    7. print(my_object.x) //output: 5    
    8. print(MyClass.myFunction) //output: <function MyClass.myFunction at 0x0000025AC1D43678>    
    9. print(my_object.myFunction) //output: <bound method MyClass.myFunction of <__main__.MyClass object at 0x000001B69C068488

    Relationship between a Class and an Object

     
    In this Example, the Class is Human, i.e a logical entity with some attributes and methods for example: hair, nose, legs, arms etc. And; Object is an entity that has state and behavior. So here, In class Human, we have Objects like man, woman and child, they may have some state and behaviour such as, sleeping, eating etc. 
     

    Polymorphism

     
    Poly means many Morphism means forms. In Polymorphism, the functions are of same name but their functionalities are different.
     
    For Example: (In-Built Polymorphism)
    1. print(len("Aashina")) //output:7    
    2. print(len([123])) //output:3  
    Let us see another example of Polymorphism ( User-Defined Polymorphism)
    1. class Jasmine():  
    2.   def color(self):  
    3.   print("Jasmine flower comes in white, pink, blue, orange, yellow, purple, and red color")  
    4.   
    5. def scientific_name(self):  
    6.   print("Jasminum sambac is scientific name of Jasmine")  
    7.   
    8. def family(self):  
    9.   print("Jasmine is from Oleaceae family")  
    10.   
    11. class Lily():  
    12.   def color(self):  
    13.   print("Lilies commonly grow in white, yellow, pink, red, and orange color.")  
    14.   
    15. def scientific_name(self):  
    16.   print("Lilium is scientific name of Lily")  
    17.   
    18. def family(self):  
    19.   print("Lily is from Liliaceae family")  
    20.   
    21. obj_jasmine = Jasmine()  
    22. obj_lily = Lily()  
    23. for flower in (obj_jasmine, obj_lily):  
    24.   flower.color()  
    25. flower.scientific_name()  
    26. flower.family() 
    Sample Output
     
     

    Inheritance

     
    By using inheritance, we can create a class which uses all the properties and behaviour of another class. In Inheritance we have a parent and a child class, as in real life a child inherits the characteristics of his/her parents, likewise, child class have properties of the parent class.
     
    Let us take the previous example again: (Polymorphism with Inheritance)
    1. class Flower():  
    2.   def color(self):  
    3.   print("Flowers are found in various colors ")  
    4.   
    5. def scientific_name(self):  
    6.   print("These are some Binomial nomenclature for categorize species")  
    7.   
    8. def family(self):  
    9.   print("Every flower have a family")  
    10.   
    11. def odour(self):  
    12.   print("Every flower have its own odour by which it can be identified")  
    13.   
    14. class Jasmine(Flower):  
    15.   def color(self):  
    16.   print("Jasmine flower comes in white, pink, blue, orange, yellow, purple, and red color")  
    17.   
    18. def scientific_name(self):  
    19.   print("Jasminum sambac is scientific name of Jasmine")  
    20.   
    21. def family(self):  
    22.   print("Jasmine is from Oleaceae family")  
    23.   
    24. class Lily(Flower):  
    25.   def color(self):  
    26.   print("Lilies commonly grow in white, yellow, pink, red, and orange color.")  
    27.   
    28. def scientific_name(self):  
    29.   print("Lilium is scientific name of Lily")  
    30.   
    31. def family(self):  
    32.   print("Lily is from Liliaceae family")  
    33.   
    34. obj_Flower = Flower()  
    35. obj_jasmine = Jasmine()  
    36. obj_lily = Lily()  
    37.   
    38. obj_Flower.color()  
    39. obj_Flower.scientific_name()  
    40. obj_Flower.family()  
    41. obj_Flower.odour()  
    42.   
    43. obj_jasmine.color()  
    44. obj_jasmine.scientific_name()  
    45. obj_jasmine.family()  
    46. obj_jasmine.odour()  
    47.   
    48. obj_lily.color()  
    49. obj_lily.scientific_name()  
    50. obj_lily.family()  
    51. obj_lily.odour() 
    Sample Output
     
     

    Encapsulation

     
    Encapsulation refers to restricting access. This is how we can wrap up and remove unnecessary data. So basically, Encapsulation is the process of using private variables within classes to prevent unintentional modification of data.
     
     
    A single underscore: Private variable, it should not be accessed directly. But nothing stops you from doing that (except convention).
     
    A double underscore: Private variable, harder to access but still possible.
     
    Both are still accessible: Python has private variables by convention.
    1. class myClass(object):  
    2.   def __init__(self):  
    3.   self.a = 123 // private variable    
    4. self._b = 123  
    5. self.__c = 123 //private variable, double underscore    
    6.   
    7. obj = myClass()  
    8. print(obj.a)  
    9. print(obj._b)  
    10. print(obj.__c)  
    Sample output
     
     
    Private variables are intended to be changed using getter and setter methods. These provide indirect access to them. 
    1. class myClass(object):  
    2.   def __init__(self):  
    3.   self.__version = 22  
    4.   
    5. def getVersion(self):  
    6.   print(self.__version)  
    7.   
    8. def setVersion(self, version):  
    9.   self.__version = version  
    10.   
    11. obj = myClass()  
    12. obj.getVersion()  
    13. obj.setVersion(23)  
    14. obj.getVersion()  
    15. print(obj.__version) 
    Sample output
     
     

    Summary

     
    In this article, we discussed about OOPS concepts, how they can be used and their major parts. I hope this will help the readers to understand how to use OOPS concepts in Python.
     
    Feedback or queries related to this article are most welcome.
     
    Thanks for reading.