{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python Object-Oriented Programming Tutorial Concepts\n",
    "Object-Oriented programming (OOP) is a popular programming pardaigm which contains the concept of \"objects\" also that includes both data and called as \"fields\"  and functions that is called as \"methods\".There are many Object-Oriented programming language ,Some of them are C++,Java,Python etc.\n",
    "\n",
    "**Python** has been an Object-Oriented language since it existed. Because of this, creating and using classes and objects are downright easy.  Python also supports the paradigm of Object-Oriented Programming.You can create and use the classes and objects easily in python.If you work as a data scientist,knowing some concepts from OOP is useful, of course, but you probably won’t use much of it.But,you can see the beauty of the Object-Oriented pradagim through Python.\n",
    "\n",
    "In any Object-Oriented programming, there are 4 basic principles that are used. These are:<br/>\n",
    "**Encapsulation:** hiding unnecessary details from the user.<br />\n",
    "**Inheritance:** reusing code from one class i.e. Properies of parent class, in the child class i.e.very similar to the the code that is needed for another class.<br />\n",
    "**Abstraction:** using what we know to work with something without knowing how it completely works (example: you don't know the inner workings of a Television, but you know how to press the buttons and you can  see news,movies etc in it ).<br />\n",
    "**Polymorphism:** taking a base class method and overwriting it so that the child class has the same method name, but a different implementation specific for that child class.i.e.It can also be taken as \"one name but different forms\".\n",
    "\n",
    "\n",
    "In this tutorial,you will see about basics of Python OOP'S in detail:\n",
    "* You will learn about the concept of Classes and Objects.\n",
    "* You will learn about Defining Classes and Objects in Python,with all the concept included in a single example.\n",
    "* You will learn about the concept of four basic principles of object-oriented programming that any Object-Oriented language     \n",
    "\n",
    "Also,be sure to follow the series of tutorials related to Object-Oriented Programming concepts in coming days to get more indepth knowledge in these topics.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Classes and Objects."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Classes\n",
    "A class is a blueprint or prototype from which objects are created.\n",
    "\n",
    "#### Objects\n",
    "Objects are a representation of the real world objects like house, dogs, bike, etc. which are bundle of related state and behaviors.The objects share two main characteristics: data called as \"fields\" and behavior and called as \"methods\".<br />\n",
    "\n",
    "**\n",
    "A class is a blueprint, a model for its objects.For Example you can think  it as a blue print for a house i.e. to create a house a blue print is needed i.e. think of it as a model and from which individual objects are created.In the real world you often find many objects with all the same type.All the same make and design(have an same area,color,same number of rooms etc).Each house was built from the same set of blueprints and has the same components.\n",
    "**\n",
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Defining a Class in Python\n",
    "\n",
    "To define a Class, in typical simple Python fashion, you can use the word ‘class,’ followed by the name of your new class.you can make a new class here, called ‘vehicles’. We use a colon after the name, and then anything contained within the class definition is indented. However, with a class, there are no parentheses:\n",
    "```\n",
    "class NameofClass:\n",
    "\n",
    "    ‘Class purpose/documentation string’\n",
    "\n",
    "    Statements to be executed, data attributes and functions\n",
    "    ```\n",
    "```\n",
    "class Car:\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Creating an Object in Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once you have created the class, you actually need to create an object for each instance of that class. In Python you can create a new variable to create an instance of a class. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "car1 = Car()\n",
    "car2 = Car()\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here is the full example showing the use of Classes and Object concept together."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "brum brum\n",
      "brum brum\n"
     ]
    }
   ],
   "source": [
    "class Car(object):\n",
    "    def __init__(self,brand, model, color):\n",
    "        # Sets all the properties\n",
    "        self.brand = brand\n",
    "        self.model = model\n",
    "        self.color = color\n",
    "        \n",
    "    def start_car(self):\n",
    "       \n",
    "        print(\"brum brum\")\n",
    "\n",
    "     \n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    # Creates two instances of new_car, each with unique properties\n",
    "    carFirst = Car(\"Tesla\",\"Model 3\",\"Grey\")\n",
    "    carSecond = Car(\"Tata\",\"Tata Nano\",\"Yellow\")\n",
    "    \n",
    "\n",
    "    carFirst.start_car();\n",
    "    carSecond.start_car();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You'll get the following output:\n",
    "```\n",
    "brum brum\n",
    "brum brum\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Python the names of special methods begin and end with double underscore - __. For example, the special method __init__ is used to initialize the state of newly created objects.For instance, we could create a new car object and set its brand, model, and year attributes on a single line, rather than expending an additional line for each attribute:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "The four principle of the any Object-Oriented programming language are as follows and only terminology is mentioned:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Encapsulation\n",
    "\n",
    "**Encapsulation** is the mechanism by which the internal representation of an object can't be seen from outside of the objects definition.Access to this data is typically only achieved through special methods: Getters and Setters.\n",
    "Encapsulation gives you more control over the degree of coupling in your code, it allows a class to change its implementation without affecting other parts of the code.\n",
    "There is kind of debate on the topic i.e.Python have encapsulation or not.Python does not have the private keyword, unlike some other Object-Oriented languages, but encapsulation can be done.Instead, it relies on the convention: a class variable that should not directly be accessed should be prefixed with an underscore."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Inheritance"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Inheritance** is a way to form new classes using classes that have already been defined. The newly formed classes are called derived classes, the classes that we derive from are called base classes. Important benefits of inheritance are code reuse and reduction of complexity of a program. The derived classes (descendants) override or extend the functionality of base classes (ancestors)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Abstraction\n",
    "**Abstraction** allows us to bundle together some related things and give a name to the bundle. Once that bundle is named, we can\n",
    "refer to it and, at times, ignore the details within the bundle. This is the onlyway to solve complex problems."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Polymorphism\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Polymorphism**is the ability to appear in the many forms also can be called as \"one name,different forms\".Polymorphism refers to a programming language's ability to process objects differently depending on their data type or class. More specifically, it is the ability to redefine methods for derived classes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Congrats!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You have made it to the end of this OOP's tutorial! In this tutorial, you learned about what basics of OOP's concept,tools that are required to make OOP's happen i.e. terminologies like classes,objects etc and also the principal of any Object-Oriented Programming language."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}